Merge branch 'package-management'

Conflicts:
	src/preferences/network/Jamfile

Jamfile

@@ -3,152 +3,45 @@ SubDir HAIKU_TOP ;
 NotFile doc_files ;
 Depends files : doc_files ;
 
-# Pseudo-target to build the mail kit only
-NotFile MailKit ;
-Depends MailKit :
-	libmail.so
-	mail_daemon
-	E-mail
-	BeMail
-
-	# mail_daemon addons
-	Inbox
-	Outbox
-	Message\ Parser
-	New\ Mail\ Notification
-	Match\ Header
-	R5\ Daemon\ Filter
-	IMAP
-	POP3
-	SMTP
-	Fortune
-	Spam\ Filter
-	spamdbm
-;
-
-# Pseudo-target to build the media stuffs only
-# TODO: don't know how to make avcodec mp3_decoder mp3_reader ogg speex vorbis
-NotFile MediaKit ;
-Depends MediaKit :
-	libmedia.so
-	libgame.so
-
-	# Servers
-	media_addon_server
-	media_server
-
-	# Preference
-	Sounds
-	Media
-
-	# Deskbar replicant
-	desklink
-
-	# add-ons
-	mixer.media_addon
-	tone_producer_demo.media_addon
-	video_producer_demo.media_addon
-	legacy.media_addon
-	multi_audio.media_addon
-#	reader.media_addon
-#	writer.media_addon
-#	demultiplexer.media_addon
-
-	# codecs
-	ac3_decoder
-	aiff_reader
-	au_reader
-	avcodec
-	avi_reader
-	matroska
-	mp3_decoder
-	mp3_reader
-	musepack
-	ogg
-	raw_decoder
-	speex
-	vorbis
-	wav_reader
-	mov_reader
-;
-
-# Pseudo-target to build the input kit only
-NotFile InputKit ;
-Depends InputKit :
-	# Servers
-	input_server
-
-	# Addons
-	<input>keyboard
-	<input>mouse
-
-	# Apps
-	keymap
-
-	# Preferences
-	Keymap
-	Keyboard
-	Mouse
-;
-
-# Pseudo-target to build the OpenGL kit only
-NotFile OpenGLKit ;
-Depends OpenGLKit :
-	libGL.so
-	GLTeapot
-#	GLInfo
-;
-
-# Pseudo-target to build the screensaver kit only
-NotFile ScreenSaverKit ;
-Depends ScreenSaverKit :
-	libscreensaver.so
-	screen_saver
-	screen_blanker
-	ScreenSaver
-	Haiku
-;
-
-# Pseudo-target to build the locale kit only
-# TODO: src/add-ons/locale/collators/GermanDIN-2.cpp does not compile
-NotFile LocaleKit ;
-Depends LocaleKit :
-	Locale
-
-	# binaries for building localized software on haiku
-	collectcatkeys
-	dumpcatalog
-	linkcatkeys
-
-	# addons
-	LocaleKitCollatorAddons
-	LocaleKitCatalogAddons
-
-	# tests
-	LocaleKitTests
-;
-
-# Add optional packages given via HAIKU_ADD_OPTIONAL_PACKAGES.
-if $(HAIKU_ADD_OPTIONAL_PACKAGES) {
-	AddOptionalHaikuImagePackages
-		[ FSplitString $(HAIKU_ADD_OPTIONAL_PACKAGES) : / ] ;
-}
-
 # Prepare the optional build features before parsing the Jamfile tree.
-include [ FDirName $(HAIKU_BUILD_RULES_DIR) BuildFeatures ] ;
+local architectureObject ;
+for architectureObject in [ MultiArchSubDirSetup ] {
+	on $(architectureObject) {
+		include [ FDirName $(HAIKU_BUILD_RULES_DIR) BuildFeatures ] ;
+	}
+}
 
 # Include packages that are required by all images.
-AddOptionalHaikuImagePackages MandatoryPackages ;
+if ! $(HAIKU_BOOTSTRAP_BUILD) {
+	# primary architecture
+	AddHaikuImagePackages
+		bzip2 ctags ffmpeg freetype glu grep icu jpeg libpng libsolv mesa sed
+		tar zlib
+		:
+		system
+		;
 
-# If enabled, make sure that OpenSSL is added to the image.
+	# secondary architectures
-if $(HAIKU_BUILD_FEATURE_OPENSSL_ENABLED) {
+	local architectureObject ;
-	AddOptionalHaikuImagePackages OpenSSL ;
+	for architectureObject
+			in [ MultiArchSubDirSetup $(HAIKU_PACKAGING_ARCHS[2-]) ] {
+		on $(architectureObject) {
+			AddHaikuImagePackages
+				ffmpeg freetype glu icu jpeg libpng libsolv mesa zlib
+				:
+				system
+				;
+		}
+	}
 }
 
-AddOptionalHaikuImagePackages ICU ;
+# If enabled, make sure that OpenSSL is added to the image.
+if [ FIsBuildFeatureEnabled openssl ] {
+	AddHaikuImagePackages openssl ;
+}
 
-# Evaluate optional package dependencies
+# add additionally requested packages
-include [ FDirName $(HAIKU_BUILD_RULES_DIR) OptionalPackageDependencies ] ;
+AddHaikuImagePackages $(HAIKU_IMAGE_ADDITIONAL_PACKAGES) ;
 
 # Optionally we allow not to include the "src" subdirectory.
 if $(HAIKU_DONT_INCLUDE_SRC) {
@@ -173,13 +66,17 @@ SubDir HAIKU_TOP ;
 UserBuildConfigRulePostBuildTargets	;
 
 # specify the Haiku image and network boot archive contents
-include [ FDirName $(HAIKU_BUILD_RULES_DIR) HaikuImage ] ;
+if $(HAIKU_BOOTSTRAP_BUILD) {
-include [ FDirName $(HAIKU_BUILD_RULES_DIR) NetBootArchive ] ;
+	include [ FDirName $(HAIKU_BUILD_RULES_DIR) images HaikuImageBootstrap ] ;
-include [ FDirName $(HAIKU_BUILD_RULES_DIR) FloppyBootImage ] ;
+} else {
-include [ FDirName $(HAIKU_BUILD_RULES_DIR) CDBootImage ] ;
+	include [ FDirName $(HAIKU_BUILD_RULES_DIR) images HaikuImage ] ;
-include [ FDirName $(HAIKU_BUILD_RULES_DIR) CDBootPPCImage ] ;
+}
-include [ FDirName $(HAIKU_BUILD_RULES_DIR) HaikuCD ] ;
+include [ FDirName $(HAIKU_BUILD_RULES_DIR) images NetBootArchive ] ;
-include [ FDirName $(HAIKU_BUILD_RULES_DIR) AnybootImage ] ;
+include [ FDirName $(HAIKU_BUILD_RULES_DIR) images FloppyBootImage ] ;
+include [ FDirName $(HAIKU_BUILD_RULES_DIR) images CDBootImage ] ;
+include [ FDirName $(HAIKU_BUILD_RULES_DIR) images CDBootPPCImage ] ;
+include [ FDirName $(HAIKU_BUILD_RULES_DIR) images HaikuCD ] ;
+include [ FDirName $(HAIKU_BUILD_RULES_DIR) images AnybootImage ] ;
 
 # Check whether all requested optional packages do actually exist.
 local package ;

Jamrules

@@ -29,6 +29,9 @@ if ! $(buildConfig) {
 LOCATE on BuildConfig = $(HAIKU_BUILD_OUTPUT_DIR) ;
 include BuildConfig ;
 
+# set HAIKU_PACKAGING_ARCH, the primary packaging architecture
+HAIKU_PACKAGING_ARCH = $(HAIKU_PACKAGING_ARCHS[1]) ;
+
 # The build setup and rules are neatly organized in several files. Include
 # them now. Start with the side-effect-less rules, since they are the most
 # likely to be used in the top level context (i.e. not only in rules).
@@ -36,7 +39,9 @@ include BuildConfig ;
 # optional user-defined UserBuildConfig is included thereafter.
 include [ FDirName $(HAIKU_BUILD_RULES_DIR) HelperRules ] ;
 include [ FDirName $(HAIKU_BUILD_RULES_DIR) MathRules ] ;
+include [ FDirName $(HAIKU_BUILD_RULES_DIR) ArchitectureRules ] ;
 include [ FDirName $(HAIKU_BUILD_RULES_DIR) BeOSRules ] ;
+include [ FDirName $(HAIKU_BUILD_RULES_DIR) BuildFeatureRules ] ;
 include [ FDirName $(HAIKU_BUILD_RULES_DIR) LocaleRules ] ;
 include [ FDirName $(HAIKU_BUILD_RULES_DIR) CommandLineArguments ] ;
 include [ FDirName $(HAIKU_BUILD_RULES_DIR) ConfigRules ] ;
@@ -51,8 +56,29 @@ include [ FDirName $(HAIKU_BUILD_RULES_DIR) MainBuildRules ] ;
 include [ FDirName $(HAIKU_BUILD_RULES_DIR) MiscRules ] ;
 include [ FDirName $(HAIKU_BUILD_RULES_DIR) OverriddenJamRules ] ;
 include [ FDirName $(HAIKU_BUILD_RULES_DIR) PackageRules ] ;
+include [ FDirName $(HAIKU_BUILD_RULES_DIR) RepositoryRules ] ;
 include [ FDirName $(HAIKU_BUILD_RULES_DIR) TestsRules ] ;
 include [ FDirName $(HAIKU_BUILD_RULES_DIR) BuildSetup ] ;
+include [ FDirName $(HAIKU_BUILD_RULES_DIR) DefaultBuildProfiles ] ;
+
+# Include the repositories for this architecture.
+local repositoriesDirectory
+	= [ FDirName $(HAIKU_BUILD_RULES_DIR) repositories ] ;
+local repositories = HaikuPorts ;
+if $(HAIKU_BOOTSTRAP_BUILD) {
+	repositories = HaikuPortsCross ;
+}
+
+local repository ;
+for repository in $(repositories) {
+	local repositoryDirectory
+		= [ FDirName $(repositoriesDirectory) $(repository) ] ;
+	local file = [ Glob $(repositoryDirectory) : $(HAIKU_PACKAGING_ARCH) ] ;
+	if $(file) {
+		HAIKU_REPOSITORY_JAMFILE = $(file) ;
+		include $(file) ;
+	}
+}
 
 # Declare no-op user-overridable build rules.
 rule UserBuildConfigRulePostBuildTargets	{ }
@@ -75,18 +101,6 @@ if ! $(HAIKU_IGNORE_USER_BUILD_CONFIG) {
 	}
 }
 
-include [ FDirName $(HAIKU_BUILD_RULES_DIR) ReleaseBuildProfiles ] ;
+DefineDefaultBuildProfiles ;
-
-# If a build profile was specified on the command line, now is the time to
-# check whether it is unknown or one of the default profiles.
-if $(HAIKU_BUILD_PROFILE) && ! $(HAIKU_BUILD_PROFILE_DEFINED) {
-	# define the obvious default profiles
-	if $(HAIKU_BUILD_PROFILE) in anyboot-image cd-image image install
-			vmware-image {
-		DefineBuildProfile $(HAIKU_BUILD_PROFILE) : $(HAIKU_BUILD_PROFILE) ;
-	} else {
-		Exit "Build profile" $(HAIKU_BUILD_PROFILE) "not defined." ;
-	}
-}
 
 PrepareConfigVariables ;

build/config_headers/tracing_config.h

@@ -58,6 +58,8 @@
 #define SYSCALL_TRACING_IGNORE_KTRACE_OUTPUT	1
 #define TCP_TRACING								0
 #define TEAM_TRACING							0
+#define TRANSLATION_MAP_TRACING					0
+#define TRANSLATION_MAP_TRACING_STACK_TRACE		0	/* stack trace depth */
 #define USER_MALLOC_TRACING						0
 #define VFS_PAGES_IO_TRACING					0
 #define VM_CACHE_TRACING						0

build/jam/AlternativeGCCArchive

@@ -1,63 +0,0 @@
-# This file defines what ends up in the alternative GCC archive and it executes
-# the rules building the archive. Included by HaikuImage.
-
-
-#sanity check - make sure the primary gcc is different than the alternative gcc
-if $(HAIKU_PRIMARY_GCC) = $(HAIKU_GCC_VERSION[1]) {
-	Exit "Error: Your alternative gcc is the same as the main gcc!"
-		"You need to reconfigure your generated directories." ;
-}
-
-#pragma mark - Build The Archive
-
-
-# archive target
-HAIKU_ALTERNATIVE_GCC_ARCHIVE = alternative_system_libs.zip ;
-MakeLocate $(HAIKU_ALTERNATIVE_GCC_ARCHIVE) : $(HAIKU_OUTPUT_DIR) ;
-
-# the pseudo target all archive contents is attached to
-NotFile $(HAIKU_ALTERNATIVE_GCC_ARCHIVE_CONTAINER_NAME) ;
-
-# prepare the script that initializes the shell variables
-local initVarsScript = <AlternativeGCCArchive>haiku-alternative-gcc-init-vars ;
-local script = $(initVarsScript) ;
-MakeLocate $(script) : $(HAIKU_OUTPUT_DIR) ;
-Always $(script) ;
-
-AddVariableToScript $(script) : tmpDir : $(HAIKU_TMP_DIR) ;
-AddVariableToScript $(script) : addBuildCompatibilityLibDir
-	: $(HOST_ADD_BUILD_COMPATIBILITY_LIB_DIR) ;
-AddTargetVariableToScript $(script) : <build>copyattr ;
-AddTargetVariableToScript $(script) : <build>zip ;
-if $(HOST_RM_ATTRS_TARGET) {
-	AddTargetVariableToScript $(script) : $(HOST_RM_ATTRS_TARGET) : rmAttrs ;
-} else {
-	AddVariableToScript $(script) : rmAttrs : rm ;
-}
-
-# create the other scripts
-local makeDirsScript = <AlternativeGCCArchive>haiku-alternative-gcc-make-dirs ;
-local copyFilesScript
-	= <AlternativeGCCArchive>haiku-alternative-gcc-copy-files ;
-MakeLocate $(makeDirsScript) $(copyFilesScript) : $(HAIKU_OUTPUT_DIR) ;
-
-CreateAlternativeGCCArchiveMakeDirectoriesScript $(makeDirsScript) ;
-CreateAlternativeGCCArchiveCopyFilesScript $(copyFilesScript) ;
-
-# build the archive
-
-BuildAlternativeGCCArchive $(HAIKU_ALTERNATIVE_GCC_ARCHIVE) :
-	$(initVarsScript)
-	$(makeDirsScript)
-	$(copyFilesScript)
-;
-
-# remove the scripts we have generated
-RmTemps $(HAIKU_ALTERNATIVE_GCC_ARCHIVE) :
-	$(initVarsScript)
-	$(makeDirsScript)
-	$(copyFilesScript)
-;
-
-NotFile haiku-alternative-gcc-archive ;
-Depends haiku-alternative-gcc-archive : $(HAIKU_ALTERNATIVE_GCC_ARCHIVE) ;

build/jam/ArchitectureRules

@@ -0,0 +1,785 @@
+rule ArchitectureSetup architecture
+{
+	# ArchitectureSetup <architecture> ;
+	#
+	# Initializes all global packaging architecture dependent variables for the
+	# given packaging architecture. Also sets HAIKU_ARCH (to the primary
+	# architecture), if this is the first invocation of the rule, and adds
+	# the architecture to HAIKU_ARCHS, if not yet contained.
+
+	# analyze GCC version
+	local gccVersion
+		= [ FAnalyzeGCCVersion HAIKU_GCC_RAW_VERSION_$(architecture) ] ;
+	HAIKU_GCC_VERSION_$(architecture) = $(gccVersion) ;
+
+	# enable GCC -pipe option, if requested
+	local gccBaseFlags ;
+	if $(HAIKU_USE_GCC_PIPE) = 1 {
+		gccBaseFlags = -pipe ;
+	}
+
+	# disable strict aliasing on anything newer than gcc 2 as it may lead to
+	# unexpected results. also disable the tree-vrp (value range propagation)
+	# optimization for now as with the current gcc4 version we are using this
+	# results in some broken code.
+	# TODO: remove the -fno-strict-aliasing option when all code has been
+	#		analyzed/fixed with regard to aliasing.
+	# TODO: retest/remove the -fno-tree-vrp option as soon as we have updated
+	#		our gcc4 compiler. See this discussion on some issues:
+	# http://www.freelists.org/post/haiku-development/hrev45320-Yet-another-nonobvious-effect-of-ftreevrp-optimization
+	if $(gccVersion[1]) >= 3 {
+		gccBaseFlags += -fno-strict-aliasing -fno-tree-vrp ;
+	}
+
+	# disable array bounds warnings on gcc 4.6 or newer since they trigger
+	# too many false positives. Coverity does a better job of this kind of
+	# analysis anyways.
+	if $(gccVersion[1]) >= 4 {
+		gccBaseFlags += -Wno-array-bounds ;
+	}
+
+	local cpu = $(HAIKU_CPU_$(architecture)) ;
+	if $(cpu) = arm {
+		# For stackcrawls
+		gccBaseFlags += -mapcs-frame ;
+	}
+
+	# activating graphite optimizations
+	if $(HAIKU_USE_GCC_GRAPHITE_$(architecture)) = 1 {
+		gccBaseFlags += -floop-interchange -ftree-loop-distribution
+			-floop-strip-mine -floop-block ;
+	}
+	HAIKU_GCC_BASE_FLAGS_$(architecture) = $(gccBaseFlags) ;
+
+	# override gcc 2.95.3's header directory -- strictly necessary only when
+	# using the BeOS native compiler (since its headers are incompatible), but
+	# it doesn't harm for the cross-compiler either.
+	if $(gccVersion[1]) = 2 {
+		HAIKU_GCC_HEADERS_DIR_$(architecture)
+			= [ FDirName $(HAIKU_TOP) headers build gcc-2.95.3 ] ;
+	}
+
+	# initial state for flags etc.
+	HAIKU_C++_$(architecture) ?= $(HAIKU_CC_$(architecture)) ;
+	HAIKU_LINK_$(architecture) = $(HAIKU_CC_$(architecture)) ;
+	HAIKU_LINKFLAGS_$(architecture) = $(gccBaseFlags) ;
+
+	HAIKU_HDRS_$(architecture) = [ FStandardHeaders $(architecture) ] ;
+	HAIKU_CCFLAGS_$(architecture) += $(gccBaseFlags) -nostdinc ;
+	HAIKU_C++FLAGS_$(architecture) += $(gccBaseFlags) -nostdinc ;
+
+	# strip is required
+	if ! $(HAIKU_STRIP_$(architecture)) {
+		Exit "HAIKU_STRIP_$(architecture) not set. Please re-run configure." ;
+	}
+
+	HAIKU_ARCH_$(architecture) = $(cpu) ;
+	HAIKU_ARCH ?= $(cpu) ;
+		# Set only, if not set yet. This way HAIKU_ARCH is set to the primary
+		# architecture.
+	if ! $(cpu) in $(HAIKU_ARCHS) {
+		HAIKU_ARCHS += $(cpu) ;
+	}
+	HAIKU_DEFINES_$(architecture) += ARCH_$(cpu) ;
+
+	# directories
+	HAIKU_ARCH_OBJECT_DIR_$(architecture)
+		= [ FDirName $(HAIKU_OBJECT_BASE_DIR) $(architecture) ] ;
+	HAIKU_COMMON_DEBUG_OBJECT_DIR_$(architecture)
+		= [ FDirName $(HAIKU_ARCH_OBJECT_DIR_$(architecture)) common ] ;
+	HAIKU_DEBUG_0_OBJECT_DIR_$(architecture)
+		= [ FDirName $(HAIKU_ARCH_OBJECT_DIR_$(architecture)) release ] ;
+
+	local level ;
+	for level in $(HAIKU_DEBUG_LEVELS[2-]) {
+		HAIKU_DEBUG_$(level)_OBJECT_DIR_$(architecture)
+			= [ FDirName $(HAIKU_ARCH_OBJECT_DIR_$(architecture))
+				debug_$(level) ] ;
+	}
+
+	# set variables for gcc header options
+	SetIncludePropertiesVariables HAIKU : _$(architecture) ;
+
+	# assembler flags
+	HAIKU_ASFLAGS_$(architecture) = ;
+
+	# C/C++ flags
+	if $(gccVersion[1]) >= 4 {
+		HAIKU_C++FLAGS_$(architecture) += -Wno-deprecated ;
+	}
+
+	switch $(cpu) {
+		case x86* :
+			# Enable use of the gcc built-in atomic functions instead of
+			# atomic_*(). The former are inlined and have thus less overhead.
+			# They are not available with gcc 2, but the header will take care
+			# of that.
+			HAIKU_DEFINES_$(architecture) += B_USE_BUILTIN_ATOMIC_FUNCTIONS ;
+	}
+
+	# warning flags
+	HAIKU_WARNING_CCFLAGS_$(architecture)
+		= -Wall -Wno-trigraphs -Wmissing-prototypes
+		-Wpointer-arith -Wcast-align -Wsign-compare -Wno-multichar ;
+	HAIKU_WARNING_C++FLAGS_$(architecture) = -Wall -Wno-trigraphs
+		-Wno-ctor-dtor-privacy -Woverloaded-virtual -Wpointer-arith -Wcast-align
+		-Wsign-compare -Wno-multichar ;
+
+	# debug flags
+	local debugFlags = -ggdb ;
+
+	# debug 0: suppress asserts
+	HAIKU_DEBUG_0_CCFLAGS_$(architecture) = [ FDefines NDEBUG=$(NDEBUG) ] ;
+	HAIKU_DEBUG_0_C++FLAGS_$(architecture) = [ FDefines NDEBUG=$(NDEBUG) ] ;
+
+	local level ;
+	for level in $(HAIKU_DEBUG_LEVELS[2-]) {
+		local flags = $(debugFlags) [ FDefines DEBUG=$(level) ] ;
+		HAIKU_DEBUG_$(level)_CCFLAGS_$(architecture) = $(flags) ;
+		HAIKU_DEBUG_$(level)_C++FLAGS_$(architecture) = $(flags) ;
+	}
+
+	if $(gccVersion[1]) >= 3 {
+		# TODO: Temporary work-around. Should be defined in the compiler specs
+		HAIKU_LINKFLAGS_$(architecture) += -Xlinker --no-undefined ;
+	} else {
+		HAIKU_DEFINES_$(architecture) += _BEOS_R5_COMPATIBLE_ ;
+	}
+
+	# private shared kernel/libroot headers
+	HAIKU_PRIVATE_SYSTEM_HEADERS_$(architecture)
+		= [ PrivateHeaders $(DOT) system system/arch/$(cpu) ] ;
+
+	# Add some grist to the libgcc objects
+	HAIKU_GCC_LIBGCC_OBJECTS_$(architecture)
+		= $(HAIKU_GCC_LIBGCC_OBJECTS_$(architecture):G=libgcc!$(architecture)) ;
+
+	# the C++ standard library
+	HAIKU_BUILD_SHARED_LIBSTDC++_$(architecture) = ;
+	if $(HAIKU_SHARED_LIBSTDC++_$(architecture)) {
+		HAIKU_LIBSTDC++_$(architecture)
+			= $(HAIKU_SHARED_LIBSTDC++_$(architecture)) ;
+	} else {
+		# no shared library available with the compiler -- build it
+		if $(gccVersion[1]) = 2 {
+			HAIKU_LIBSTDC++_$(architecture) = libstdc++.r4.so ;
+		} else {
+			HAIKU_LIBSTDC++_$(architecture) = <$(architecture)>libstdc++.so ;
+		}
+		HAIKU_SHARED_LIBSTDC++_$(architecture)
+			= $(HAIKU_LIBSTDC++_$(architecture)) ;
+		HAIKU_BUILD_SHARED_LIBSTDC++_$(architecture) = 1 ;
+	}
+
+	# the C++ support (runtime) library
+	HAIKU_BUILD_SHARED_LIBSUPC++_$(architecture) = ;
+	if $(HAIKU_SHARED_LIBSUPC++_$(architecture)) {
+		HAIKU_LIBSUPC++_$(architecture)
+			= $(HAIKU_SHARED_LIBSUPC++_$(architecture)) ;
+	} else {
+		# no shared library available with the compiler -- build it for gcc 4
+		if $(gccVersion[1]) != 2 {
+			HAIKU_SHARED_LIBSUPC++_$(architecture)
+				= <$(architecture)>libsupc++.so ;
+			HAIKU_BUILD_SHARED_LIBSUPC++_$(architecture) = 1 ;
+		}
+
+		HAIKU_LIBSUPC++_$(architecture)
+			= $(HAIKU_SHARED_LIBSUPC++_$(architecture)) ;
+	}
+
+	# library and executable glue code
+	local commonGlueCode =
+		<src!system!glue!$(architecture)>init_term_dyn.o
+		<src!system!glue!arch!$(HAIKU_ARCH)!$(architecture)>crti.o
+		<src!system!glue!arch!$(HAIKU_ARCH)!$(architecture)>crtn.o
+		;
+	HAIKU_LIBRARY_BEGIN_GLUE_CODE_$(architecture) =
+		<src!system!glue!arch!$(HAIKU_ARCH)!$(architecture)>crti.o
+		<$(architecture)>crtbegin.o
+		<src!system!glue!$(architecture)>init_term_dyn.o
+		;
+	HAIKU_LIBRARY_END_GLUE_CODE_$(architecture) =
+		<$(architecture)>crtend.o
+		<src!system!glue!arch!$(HAIKU_ARCH)!$(architecture)>crtn.o
+		;
+	HAIKU_EXECUTABLE_BEGIN_GLUE_CODE_$(architecture) =
+		<src!system!glue!arch!$(HAIKU_ARCH)!$(architecture)>crti.o
+		<$(architecture)>crtbegin.o
+		<src!system!glue!$(architecture)>start_dyn.o
+		<src!system!glue!$(architecture)>init_term_dyn.o
+		;
+	HAIKU_EXECUTABLE_END_GLUE_CODE_$(architecture)
+		= $(HAIKU_LIBRARY_END_GLUE_CODE_$(architecture)) ;
+
+	SEARCH on <$(architecture)>crtbegin.o <$(architecture)>crtend.o
+		= $(HAIKU_GCC_LIB_DIR_$(architecture)) ;
+
+	# init library name map
+	local libraryGrist = "" ;
+	if $(architecture) != $(HAIKU_PACKAGING_ARCHS[1]) {
+		libraryGrist = $(architecture) ;
+	}
+	local i ;
+	for i in be bnetapi debug device game GL locale mail media midi midi2
+			network opengl package root screensaver textencoding tracker
+			translation z {
+		local library = lib$(i).so ;
+		HAIKU_LIBRARY_NAME_MAP_$(architecture)_$(i)
+			= $(library:G=$(libraryGrist)) ;
+	}
+	HAIKU_LIBRARY_NAME_MAP_$(architecture)_libstdc++
+		= $(HAIKU_LIBSTDC++_$(architecture)) ;
+	HAIKU_LIBRARY_NAME_MAP_$(architecture)_libsupc++
+		= $(HAIKU_LIBSUPC++_$(architecture)) ;
+	HAIKU_LIBRARY_NAME_MAP_$(architecture)_localestub
+		= <$(architecture)>liblocalestub.a ;
+	if $(architecture) = $(HAIKU_PACKAGING_ARCHS[1]) {
+		HAIKU_LIBRARY_NAME_MAP_$(architecture)_input_server
+			= <nogrist>input_server ;
+	} else {
+		HAIKU_LIBRARY_NAME_MAP_$(architecture)_input_server
+			= <$(architecture)>input_server ;
+	}
+}
+
+
+rule KernelArchitectureSetup architecture
+{
+	# KernelArchitectureSetup <architecture> ;
+	#
+	# Initializes the global kernel and boot loader related variables. Those
+	# don't have a packaging architecture suffix, since they are only set for
+	# the primary packaging architecture. <architecture> is the primary
+	# packaging architecture (supplied for convenience).
+
+	HAIKU_KERNEL_ARCH = $(HAIKU_ARCH) ;
+
+	local gccVersion = $(HAIKU_GCC_VERSION_$(architecture)) ;
+	local cpu = $(HAIKU_CPU_$(architecture)) ;
+
+	switch $(cpu) {
+		case ppc :
+			HAIKU_BOOT_PLATFORM ?= openfirmware ;
+			HAIKU_BOOT_FLOPPY_IMAGE_SIZE = 1440 ; # in kB
+			# offset in floppy image (>= sizeof(haiku_loader))
+			HAIKU_BOOT_ARCHIVE_IMAGE_OFFSET = 192 ; # in kB - unused yet
+
+		case arm :
+			HAIKU_BOOT_PLATFORM ?= u-boot ;
+			HAIKU_BOOT_BOARD ?= verdex ;
+			HAIKU_BOOT_FLOPPY_IMAGE_SIZE = 1440 ;
+				# in kB (there is not really a floppy on the gumstix ;) )
+			# offset in floppy image (>= sizeof(haiku_loader))
+			HAIKU_BOOT_ARCHIVE_IMAGE_OFFSET = 192 ; # in kB - unused yet
+
+		case x86 :
+			HAIKU_BOOT_PLATFORM = bios_ia32 ;
+			HAIKU_BOOT_FLOPPY_IMAGE_SIZE = 2880 ; # in kB
+			# offset in floppy image (>= sizeof(haiku_loader))
+			HAIKU_BOOT_ARCHIVE_IMAGE_OFFSET = 300 ; # in kB
+
+			# yasm is required for target arch x86
+			if ! $(HAIKU_YASM) {
+				Exit "HAIKU_YASM not set. Please re-run configure." ;
+			}
+
+		case x86_64 :
+			# x86_64 completely shares the x86 bootloader.
+			HAIKU_BOOT_PLATFORM = bios_ia32 ;
+			HAIKU_BOOT_FLOPPY_IMAGE_SIZE = 2880 ; # in kB
+			# offset in floppy image (>= sizeof(haiku_loader))
+			HAIKU_BOOT_ARCHIVE_IMAGE_OFFSET = 300 ; # in kB
+
+			# x86_64 kernel source is under arch/x86.
+			HAIKU_KERNEL_ARCH = x86 ;
+
+			# yasm is required for target arch x86_64
+			if ! $(HAIKU_YASM) {
+				Exit "HAIKU_YASM not set. Please re-run configure." ;
+			}
+
+		case m68k :
+			HAIKU_BOOT_PLATFORM ?= atari_m68k ;
+			switch $(HAIKU_BOOT_PLATFORM) {
+				case atari_m68k :
+				{
+					HAIKU_BOOT_FLOPPY_IMAGE_SIZE = 1440 ; # in kB
+				}
+				case amiga_m68k :
+				{
+					# for now we have trouble reading from double-sided images
+					HAIKU_BOOT_FLOPPY_IMAGE_SIZE = 880 ; # in kB
+				}
+			}
+			# offset in floppy image (>= sizeof(haiku_loader))
+			HAIKU_BOOT_ARCHIVE_IMAGE_OFFSET = 260 ; # in kB
+
+		case mipsel :
+			# RouterBOARD firmware (ELF image over TFTP)
+			HAIKU_BOOT_PLATFORM = routerboard_mipsel ;
+			# offset in floppy image (>= sizeof(haiku_loader))
+			HAIKU_BOOT_ARCHIVE_IMAGE_OFFSET = 192 ; # in kB
+
+		case * :
+			Exit "Currently unsupported target CPU:" $(cpu) ;
+	}
+
+	# Include embedded board-specific file.
+	if $(HAIKU_BOOT_BOARD) {
+		include [ FDirName $(HAIKU_BUILD_RULES_DIR) board $(HAIKU_BOOT_BOARD)
+			BoardSetup ] ;
+	}
+
+	# private kernel headers to be used when compiling kernel code
+	HAIKU_PRIVATE_KERNEL_HEADERS =
+		[ PrivateHeaders $(DOT) kernel libroot shared
+			kernel/boot/platform/$(HAIKU_BOOT_PLATFORM) ]
+		[ ArchHeaders $(HAIKU_KERNEL_ARCH) ]
+		[ FDirName $(HAIKU_COMMON_DEBUG_OBJECT_DIR_$(architecture)) system
+			kernel ]
+		$(HAIKU_PRIVATE_SYSTEM_HEADERS_$(architecture))
+		;
+
+	# C/C++ flags
+	local gccBaseFlags = $(HAIKU_GCC_BASE_FLAGS_$(architecture))
+		-finline -fno-builtin ;
+
+	if $(gccVersion[1]) >= 4 {
+		gccBaseFlags += -ffreestanding ;
+	}
+
+	local g++BaseFlags = $(gccBaseFlags) -fno-exceptions ;
+
+	if $(gccVersion[1]) >= 3 {
+		g++BaseFlags += -fno-use-cxa-atexit ;
+	}
+
+	HAIKU_KERNEL_CCFLAGS = $(HAIKU_CCFLAGS_$(architecture)) $(gccBaseFlags) ;
+	HAIKU_KERNEL_C++FLAGS = $(HAIKU_C++FLAGS_$(architecture)) $(g++BaseFlags) ;
+	HAIKU_BOOT_CCFLAGS = $(HAIKU_CCFLAGS_$(architecture)) $(gccBaseFlags) ;
+	HAIKU_BOOT_C++FLAGS = $(HAIKU_C++FLAGS_$(architecture)) $(g++BaseFlags) ;
+	HAIKU_BOOT_LINKFLAGS = ;
+
+	HAIKU_KERNEL_PIC_CCFLAGS = -fno-pic ;
+	HAIKU_KERNEL_PIC_LINKFLAGS = ;
+	HAIKU_KERNEL_ADDON_LINKFLAGS = ;
+
+	switch $(cpu) {
+		case ppc :
+			# Build a position independent PPC kernel. We need to be able to
+			# relocate the kernel, since the virtual address space layout at
+			# boot time is not fixed.
+			HAIKU_KERNEL_PIC_CCFLAGS = -fPIE ;
+			HAIKU_KERNEL_PIC_LINKFLAGS = -shared -fPIE ;
+
+		case m68k :
+			# We don't want to have to handle emulating missing FPU opcodes for
+			# 040 and 060 in the kernel.
+			HAIKU_KERNEL_CCFLAGS += -m68020-60 ;
+			HAIKU_KERNEL_C++FLAGS += -m68020-60 ;
+
+		case x86 :
+			HAIKU_KERNEL_CCFLAGS += -march=pentium ;
+			HAIKU_KERNEL_C++FLAGS += -march=pentium ;
+
+		case x86_64 :
+			# Kernel lives in the top 2GB of the address space, use kernel code
+			# model.
+			HAIKU_KERNEL_PIC_CCFLAGS += -mcmodel=kernel ;
+
+			# Disable the red zone, which cannot be used in kernel code due to
+			# interrupts, and always enable the frame pointer so stack traces
+			# are correct.
+			HAIKU_KERNEL_CCFLAGS += -mno-red-zone -fno-omit-frame-pointer ;
+			HAIKU_KERNEL_C++FLAGS += -mno-red-zone -fno-omit-frame-pointer ;
+			HAIKU_KERNEL_PIC_LINKFLAGS += -z max-page-size=0x1000 ;
+			HAIKU_KERNEL_ADDON_LINKFLAGS += -z max-page-size=0x1000 ;
+
+			# Bootloader is 32-bit.
+			HAIKU_BOOT_LINKFLAGS += -m elf_i386_haiku ;
+			HAIKU_BOOT_CCFLAGS += -m32 -march=pentium ;
+			HAIKU_BOOT_C++FLAGS += -m32 -march=pentium ;
+	}
+
+	# warning flags
+	HAIKU_KERNEL_WARNING_CCFLAGS = -Wall -Wno-trigraphs -Wmissing-prototypes
+		-Wno-multichar ;
+	HAIKU_KERNEL_WARNING_C++FLAGS = -Wall -Wno-trigraphs -Wno-multichar ;
+
+	# debug flags
+	local level ;
+	for level in $(HAIKU_DEBUG_LEVELS) {
+		local flags = $(HAIKU_DEBUG_FLAGS) [ FDefines DEBUG=$(level) ] ;
+		HAIKU_KERNEL_DEBUG_$(level)_CCFLAGS
+			= $(HAIKU_DEBUG_$(level)_CCFLAGS_$(architecture)) ;
+		HAIKU_KERNEL_DEBUG_$(level)_C++FLAGS
+			= $(HAIKU_DEBUG_$(level)_C++FLAGS_$(architecture)) ;
+	}
+
+	# defines
+	HAIKU_KERNEL_DEFINES += _KERNEL_MODE ;
+
+	HAIKU_DEFINES_$(architecture)
+		+= BOOT_ARCHIVE_IMAGE_OFFSET=$(HAIKU_BOOT_ARCHIVE_IMAGE_OFFSET) ;
+		# TODO: That doesn't need to be a general define. It's just needed for
+		# compiling (part of) the boot loader.
+
+	# kernel add-on glue code
+	HAIKU_KERNEL_ADDON_BEGIN_GLUE_CODE = <$(architecture)>crtbegin.o
+		<src!system!glue!$(architecture)>haiku_version_glue.o ;
+	HAIKU_KERNEL_ADDON_END_GLUE_CODE
+		= $(HAIKU_GCC_LIBGCC_$(architecture)) <$(architecture)>crtend.o ;
+}
+
+
+rule ArchitectureSetupWarnings architecture
+{
+	# ArchitectureSetupWarnings <architecture> ;
+	#
+	# Sets up compiler warnings and error flags for various subdirectories for
+	# the given packaging architecture.
+
+	local cpu = $(HAIKU_CPU_$(architecture)) ;
+	switch $(cpu) {
+		case arm :
+			return ;
+				# we use #warning as placeholders for things to write...
+		case m68k :
+			return ;
+				# we use #warning as placeholders for things to write...
+		case mipsel :
+			return ;
+				# we use #warning as placeholders for things to write...
+	}
+
+
+	# enable -Werror for certain parts of the source tree
+	HAIKU_WERRORFLAGS = ;
+	local gccVersion = $(HAIKU_GCC_VERSION_$(architecture)) ;
+	if $(gccVersion[1]) >= 4 {
+		# -Wuninitialized gives too many false positives.
+		HAIKU_WERRORFLAGS = -Wno-error=uninitialized ;
+
+		# TODO: remove the -Wno-unused-but-set-variable option
+		HAIKU_WERRORFLAGS += -Wno-unused-but-set-variable ;
+	}
+
+	HAIKU_WERROR_ARCH = $(architecture) ;
+
+	rule EnableWerror dirTokens : scope {
+		AppendToConfigVar TARGET_WARNING_CCFLAGS_$(HAIKU_WERROR_ARCH)
+			: HAIKU_TOP $(dirTokens)
+			: -Werror $(HAIKU_WERRORFLAGS) : $(scope) ;
+		AppendToConfigVar TARGET_WARNING_C++FLAGS_$(HAIKU_WERROR_ARCH)
+			: HAIKU_TOP $(dirTokens)
+			: -Werror $(HAIKU_WERRORFLAGS) : $(scope) ;
+	}
+
+	# Work-around for GCC 2 problem -- despite -Wno-multichar it reports
+	# multichar warnings in headers/private/kernel/debugger_keymaps.h included
+	# by src/system/kernel/arch/x86/arch_debug_console.cpp.
+	if $(gccVersion[1]) = 2 {
+		local file = <src!system!kernel!arch!x86>arch_debug_console.o ;
+		TARGET_WARNING_C++FLAGS_$(architecture) on $(file)
+			= [ on $(file) return $(TARGET_WARNING_C++FLAGS_$(architecture)) ] ;
+	}
+
+	EnableWerror src add-ons accelerants 3dfx ;
+	EnableWerror src add-ons accelerants ati ;
+	EnableWerror src add-ons accelerants common ;
+	EnableWerror src add-ons accelerants et6x00 ;
+#	EnableWerror src add-ons accelerants intel_extreme ;
+#	EnableWerror src add-ons accelerants matrox ;
+	EnableWerror src add-ons accelerants neomagic ;
+#	EnableWerror src add-ons accelerants nvidia ;
+	EnableWerror src add-ons accelerants nvidia_gpgpu ;
+#	EnableWerror src add-ons accelerants radeon ;
+#	EnableWerror src add-ons accelerants radeon_hd ;
+	EnableWerror src add-ons accelerants s3 ;
+	EnableWerror src add-ons accelerants skeleton ;
+	EnableWerror src add-ons accelerants vesa ;
+	EnableWerror src add-ons accelerants via ;
+	EnableWerror src add-ons accelerants vmware ;
+	EnableWerror src add-ons bluetooth ;
+	EnableWerror src add-ons decorators ;
+	EnableWerror src add-ons disk_systems ;
+	EnableWerror src add-ons input_server devices ;
+#	EnableWerror src add-ons input_server filters ;
+#	EnableWerror src add-ons input_server methods ;
+	EnableWerror src add-ons kernel bluetooth ;
+#	EnableWerror src add-ons kernel bus_managers acpi ;
+	EnableWerror src add-ons kernel bus_managers agp_gart ;
+	EnableWerror src add-ons kernel bus_managers ata ;
+	EnableWerror src add-ons kernel bus_managers config_manager ;
+#	EnableWerror src add-ons kernel bus_managers firewire ;
+	EnableWerror src add-ons kernel bus_managers isa ;
+	EnableWerror src add-ons kernel bus_managers pci ;
+#	EnableWerror src add-ons kernel bus_managers ps2 ; # gcc2
+	EnableWerror src add-ons kernel bus_managers scsi ;
+	EnableWerror src add-ons kernel bus_managers usb ;
+	EnableWerror src add-ons kernel busses agp_gart ;
+	EnableWerror src add-ons kernel busses ata ;
+	EnableWerror src add-ons kernel busses scsi ;
+	EnableWerror src add-ons kernel busses usb ;
+	EnableWerror src add-ons kernel console ;
+	EnableWerror src add-ons kernel cpu ;
+#	EnableWerror src add-ons kernel debugger ; # gcc2
+#	EnableWerror src add-ons kernel drivers audio ;
+	EnableWerror src add-ons kernel drivers bluetooth ;
+	EnableWerror src add-ons kernel drivers bus ;
+	EnableWerror src add-ons kernel drivers common ;
+	EnableWerror src add-ons kernel drivers disk ;
+	EnableWerror src add-ons kernel drivers dvb ;
+#	EnableWerror src add-ons kernel drivers graphics ;
+#	EnableWerror src add-ons kernel drivers input ;
+	EnableWerror src add-ons kernel drivers joystick ;
+	EnableWerror src add-ons kernel drivers midi ;
+	EnableWerror src add-ons kernel drivers misc ;
+#	EnableWerror src add-ons kernel drivers network ;
+	EnableWerror src add-ons kernel drivers ports ;
+#	EnableWerror src add-ons kernel drivers power ;
+	EnableWerror src add-ons kernel drivers printer ;
+	EnableWerror src add-ons kernel drivers random ;
+	EnableWerror src add-ons kernel drivers tty ;
+	EnableWerror src add-ons kernel drivers video ;
+	EnableWerror src add-ons kernel file_systems bfs ;
+	EnableWerror src add-ons kernel file_systems cdda ;
+#	EnableWerror src add-ons kernel file_systems ext2 ;
+#	EnableWerror src add-ons kernel file_systems fat ;
+#	EnableWerror src add-ons kernel file_systems googlefs ;
+	EnableWerror src add-ons kernel file_systems iso9660 ;
+	EnableWerror src add-ons kernel file_systems layers ;
+	EnableWerror src add-ons kernel file_systems netfs ;
+	EnableWerror src add-ons kernel file_systems nfs ;
+	EnableWerror src add-ons kernel file_systems nfs4 ;
+#	EnableWerror src add-ons kernel file_systems ntfs ;
+	EnableWerror src add-ons kernel file_systems packagefs ;
+	EnableWerror src add-ons kernel file_systems ramfs ;
+#	EnableWerror src add-ons kernel file_systems reiserfs ;
+	EnableWerror src add-ons kernel file_systems udf ;
+	EnableWerror src add-ons kernel file_systems userlandfs ;
+	EnableWerror src add-ons kernel generic ;
+#	EnableWerror src add-ons kernel network datalink_protocols ;
+	EnableWerror src add-ons kernel network devices ;
+	EnableWerror src add-ons kernel network dns_resolver ;
+	EnableWerror src add-ons kernel network notifications ;
+	EnableWerror src add-ons kernel network ppp ;
+	EnableWerror src add-ons kernel network protocols ;
+#	EnableWerror src add-ons kernel network stack ;
+	EnableWerror src add-ons kernel partitioning_systems ;
+	EnableWerror src add-ons locale ;
+	EnableWerror src add-ons mail_daemon ;
+	EnableWerror src add-ons media media-add-ons demultiplexer ;
+	EnableWerror src add-ons media media-add-ons dvb ;
+	EnableWerror src add-ons media media-add-ons esound_sink ;
+	EnableWerror src add-ons media media-add-ons finepix_webcam ;
+	EnableWerror src add-ons media media-add-ons firewire_dv ;
+	EnableWerror src add-ons media media-add-ons legacy ;
+	EnableWerror src add-ons media media-add-ons mixer ;
+	EnableWerror src add-ons media media-add-ons multi_audio ;
+	EnableWerror src add-ons media media-add-ons opensound ;
+	EnableWerror src add-ons media media-add-ons radeon ;
+	EnableWerror src add-ons media media-add-ons reader ;
+	EnableWerror src add-ons media media-add-ons tone_producer_demo ;
+	EnableWerror src add-ons media media-add-ons usb_vision ;
+#	EnableWerror src add-ons media media-add-ons usb_webcam ;
+	EnableWerror src add-ons media media-add-ons video_mixer ;
+#	EnableWerror src add-ons media media-add-ons video_producer_demo ;
+	EnableWerror src add-ons media media-add-ons videowindow ;
+	EnableWerror src add-ons media media-add-ons writer ;
+	EnableWerror src add-ons media plugins ac3_decoder ;
+	EnableWerror src add-ons media plugins aiff_reader ;
+	EnableWerror src add-ons media plugins ape_reader ;
+#	EnableWerror src add-ons media plugins asf_reader ;
+	EnableWerror src add-ons media plugins au_reader ;
+#	EnableWerror src add-ons media plugins avi_reader ;
+#	EnableWerror src add-ons media plugins ffmpeg ;
+#	EnableWerror src add-ons media plugins matroska ;
+#	EnableWerror src add-ons media plugins mov_reader ;
+	EnableWerror src add-ons media plugins mp3_decoder ;
+#	EnableWerror src add-ons media plugins mp3_reader ;
+	EnableWerror src add-ons media plugins mp4_reader ;
+	EnableWerror src add-ons media plugins musepack ;
+#	EnableWerror src add-ons media plugins ogg ;
+#	EnableWerror src add-ons media plugins raw_decoder ;
+#	EnableWerror src add-ons media plugins speex ;
+	EnableWerror src add-ons media plugins theora ;
+	EnableWerror src add-ons media plugins vorbis ;
+#	EnableWerror src add-ons media plugins wav_reader ;
+	EnableWerror src add-ons media plugins xvid_decoder ;
+	EnableWerror src add-ons opengl ;
+	EnableWerror src add-ons print ;
+	EnableWerror src add-ons screen_savers ;
+	EnableWerror src add-ons tracker ;
+	EnableWerror src add-ons translators bmp ;
+#	EnableWerror src add-ons translators exr ;
+	EnableWerror src add-ons translators gif ;
+#	EnableWerror src add-ons translators hpgs ;
+	EnableWerror src add-ons translators hvif ;
+	EnableWerror src add-ons translators ico ;
+#	EnableWerror src add-ons translators jpeg ; # gcc2
+	EnableWerror src add-ons translators jpeg2000 ;
+	EnableWerror src add-ons translators pcx ;
+#	EnableWerror src add-ons translators png ; # gcc2
+	EnableWerror src add-ons translators ppm ;
+	EnableWerror src add-ons translators raw ;
+	EnableWerror src add-ons translators rtf ;
+	EnableWerror src add-ons translators sgi ;
+	EnableWerror src add-ons translators shared ;
+#	EnableWerror src add-ons translators stxt ;
+	EnableWerror src add-ons translators tga ;
+	EnableWerror src add-ons translators tiff ;
+#	EnableWerror src add-ons translators wonderbrush ;
+	EnableWerror src add-ons print ;
+	EnableWerror src bin multiuser ;
+	EnableWerror src bin package ;
+	EnableWerror src bin package_repo ;
+	EnableWerror src bin pkgman ;
+	EnableWerror src apps ;
+	EnableWerror src kits ;
+	EnableWerror src preferences ;
+	EnableWerror src servers ;
+	EnableWerror src system kernel ;
+	EnableWerror src system libroot add-ons ;
+	EnableWerror src system libroot posix locale ;
+	EnableWerror src system libroot posix wchar ;
+	EnableWerror src system runtime_loader ;
+}
+
+
+rule MultiArchIfPrimary ifValue : elseValue : architecture
+{
+	# MultiArchIfPrimary <ifValue> : <elseValue>
+	#	[ : <architecture> = $(TARGET_PACKAGING_ARCH) ] ;
+	#
+	# Returns one of the two given values depending on whether
+	# <architecture> is the primary packaging architecture.
+
+	architecture ?= $(TARGET_PACKAGING_ARCH) ;
+
+	if $(architecture) = $(TARGET_PACKAGING_ARCHS[1]) {
+		return $(ifValue) ;
+	}
+	return $(elseValue) ;
+}
+
+
+rule MultiArchConditionalGristFiles files : primaryGrist : secondaryGrist
+	: architecture
+{
+	# MultiArchConditionalGristFiles <files> : <primaryGrist>
+	#	: <secondaryGrist> [ : <architecture> = $(TARGET_PACKAGING_ARCH) ] ;
+	#
+	# Returns <files> with their grist set to either <primaryGrist> or
+	# <secondaryGrist> depending on whether <architecture> is the primary
+	# packaging architecture.
+
+	architecture ?= $(TARGET_PACKAGING_ARCH) ;
+
+	local grist = [ MultiArchIfPrimary $(primaryGrist) : $(secondaryGrist)
+		: $(architecture) ] ;
+	return $(files:G=$(grist:E=)) ;
+}
+
+
+rule MultiArchDefaultGristFiles files : gristPrefix : architecture
+{
+	# MultiArchDefaultGristFiles <files> : <gristPrefix>
+	#	[ : <architecture> = $(TARGET_PACKAGING_ARCH) ] ;
+	#
+	# Convenient shorthand for MultiArchConditionalGristFiles for the common
+	# case that for a secondary packaging architecture the packaging
+	# architecture name shall be appended to the grist while it shall be omitted
+	# for the primary packaging architecture. IOW, if architecture is the
+	# primary packaging architecture, <files> are returned with their grist set
+	# to <gristPrefix>, otherwise <files> are returned with their grist set to
+	# <gristPrefix>!<architecture> respectively <architecture> (if <gristPrefix>
+	# is empty).
+
+	architecture ?= $(TARGET_PACKAGING_ARCH) ;
+
+	local secondaryGrist = $(gristPrefix)!$(architecture) ;
+	secondaryGrist ?= $(architecture) ;
+
+	return [ MultiArchConditionalGristFiles $(files) : $(gristPrefix) :
+		$(secondaryGrist) : $(architecture) ] ;
+}
+
+
+rule MultiArchSubDirSetup architectures
+{
+	# MultiArchSubDirSetup <architectures> ;
+	#
+	# For each of the given packaging architectures <architectures> that are
+	# in the packaging architectures configured for the build (or all configured
+	# packaging architectures, if <architectures> is empty) an object is
+	# prepared that can be used for an "on ... { ... }" block to set up subdir
+	# variables for the respective packaging architecture. Most notably
+	# TARGET_PACKAGING_ARCH, TARGET_ARCH, TARGET_LIBSUPC++, and TARGET_LIBSTDC++
+	# are set to the values for the respective packaging architecture. The
+	# per-subdir variables SOURCE_GRIST, LOCATE_TARGET, LOCATE_SOURCE,
+	# SEARCH_SOURCE, *_LOCATE_TARGET, are reset. All SUBDIR* and config
+	# variables are set to the values they had when this rule was invoked.
+
+	local result ;
+	architectures ?= $(TARGET_PACKAGING_ARCHS) ;
+	local architecture ;
+	for architecture in $(architectures) {
+		if ! $(architecture) in $(TARGET_PACKAGING_ARCHS) {
+			continue ;
+		}
+
+		local architectureObject = $(architecture:G=<arch-object>) ;
+		result += $(architectureObject) ;
+
+		# Set the variables that default to the values of the respective
+		# variables for the primary architecture.
+		TARGET_PACKAGING_ARCH on $(architectureObject) = $(architecture) ;
+
+		local var ;
+		for var in TARGET_ARCH TARGET_LIBSUPC++ TARGET_LIBSTDC++ {
+			$(var) on $(architectureObject) = $($(var)_$(architecture)) ;
+		}
+
+		# Clone the current config variable values and the variables SubDir
+		# resets.
+		for var in $(AUTO_SET_UP_CONFIG_VARIABLES) SUBDIR$(SUBDIRRESET) {
+			$(var) on $(architectureObject) = $($(var)) ;
+		}
+
+		# adjust SOURCE_GRIST
+		SOURCE_GRIST on $(architectureObject)
+			= $(SOURCE_GRIST:E=)!$(architecture) ;
+
+		# Adjust the subdir's object dirs that are architecture dependent. To
+		# avoid duplicating the code from SetupObjectsDir, we call it. Since it
+		# sets global variables, we set these variables on our object, call
+		# SetupObjectsDir in an "on" block, and grab the new variable values.
+		local hostTarget = HOST TARGET ;
+		local objectDirVars =
+			COMMON_ARCH COMMON_DEBUG DEBUG_$(HAIKU_DEBUG_LEVELS)
+			;
+		objectDirVars =
+			COMMON_PLATFORM_LOCATE_TARGET
+			$(hostTarget)_$(objectDirVars)_LOCATE_TARGET
+			LOCATE_TARGET
+			LOCATE_SOURCE
+			SEARCH_SOURCE
+			;
+
+		for var in $(objectDirVars) {
+			$(var) on $(architectureObject) = ;
+		}
+
+		on $(architectureObject) {
+			SetupObjectsDir ;
+
+			for var in $(objectDirVars) {
+				$(var) on $(architectureObject) = $($(var)) ;
+			}
+		}
+	}
+
+	return $(result) ;
+}

build/jam/BeOSRules

@@ -149,34 +149,70 @@ actions SetVersion1
 	$(2[1]) "$(1)" -system $(HAIKU_BUILD_VERSION) -short "$(HAIKU_BUILD_DESCRIPTION)" ;
 }
 
-rule SetType
+rule SetType target : type
 {
-	# SetType <target>
+	# SetType <target> [ : <type> ]
+	# Sets the MIME type on the target. If none is given, the executable MIME
+	# type is used.
 
-	Depends $(1) : <build>settype ;
+	TARGET_MIME_TYPE on $(target) = $(type:E=$(TARGET_EXECUTABLE_MIME_TYPE)) ;
-	SetType1 $(1) : <build>settype ;
+
+	Depends $(target) : <build>settype ;
+	SetType1 $(target) : <build>settype ;
 }
 
 actions SetType1
 {
 	$(HOST_ADD_BUILD_COMPATIBILITY_LIB_DIR)
-	$(2[1]) -t $(TARGET_EXECUTABLE_MIME_TYPE) "$(1)" ;
+	$(2[1]) -t $(TARGET_MIME_TYPE) "$(1)" ;
 }
 
-rule MimeSet
+rule MimeSet target
 {
-	# MimeSet <target>
+	# MimeSet <target> ;
 
-	Depends $(1) : <build>mimeset ;
+	Depends $(target) : <build>mimeset <mimedb>mime_db ;
-	MimeSet1 $(1) : <build>mimeset ;
+	MimeSet1 $(target) : <build>mimeset <mimedb>mime_db ;
 }
 
+
 actions MimeSet1
 {
 	$(HOST_ADD_BUILD_COMPATIBILITY_LIB_DIR)
-	$(2[1]) -f "$(1)" ;
+	$(2[1]) -f --mimedb "$(2[2])" "$(1)"
 }
 
+
+rule CreateAppMimeDBEntries target
+{
+	# MimeSetApp <target> ;
+	# Create the app meta MIME DB entries for the given target. The
+	# HAIKU_MIME_DB_ENTRIES variable on <target> is set to the generated
+	# resulting target directory that contains the MIME DB entries.
+
+	local appGrist = $(target:G) ;
+	local appMimeDB = $(target:BS)_mimedb ;
+	appMimeDB = $(appMimeDB:G=mimedb-app-$(appGrist:E=)) ;
+	MakeLocateDebug $(appMimeDB) ;
+	Depends $(appMimeDB) : <build>mimeset $(target) <mimedb>mime_db ;
+	CreateAppMimeDBEntries1 $(appMimeDB)
+		: <build>mimeset $(target) <mimedb>mime_db ;
+
+	HAIKU_MIME_DB_ENTRIES on $(target) = $(appMimeDB) ;
+}
+
+
+actions CreateAppMimeDBEntries1
+{
+	$(HOST_ADD_BUILD_COMPATIBILITY_LIB_DIR)
+
+	appMimeDB="$(1)"
+	$(RM) -rf "$appMimeDB"
+	$(MKDIR) "$appMimeDB"
+	$(2[1]) -f --apps --mimedb "$appMimeDB" --mimedb "$(2[3])" "$(2[2])"
+}
+
+
 rule ResComp
 {
 	# ResComp <resource file> : <rdef file> ;
@@ -196,9 +232,11 @@ rule ResComp
 			cc = $(HOST_CC) ;
 			localIncludesOption = $(HOST_LOCAL_INCLUDES_OPTION) ;
 		} else {
-			defines += $(TARGET_DEFINES) ;
+			defines += $(TARGET_DEFINES_$(TARGET_PACKAGING_ARCH))
-			cc = $(TARGET_CC) ;
+				$(TARGET_DEFINES) ;
-			localIncludesOption = $(TARGET_LOCAL_INCLUDES_OPTION) ;
+			cc = $(TARGET_CC_$(TARGET_PACKAGING_ARCH)) ;
+			localIncludesOption
+				= $(TARGET_LOCAL_INCLUDES_OPTION_$(TARGET_PACKAGING_ARCH)) ;
 		}
 	}
 

build/jam/BootRules

@@ -24,8 +24,9 @@ rule SetupBoot
         ASFLAGS on $(object) = $(TARGET_BOOT_CCFLAGS) ;
 
 		# override warning flags
-		TARGET_WARNING_CCFLAGS on $(object) = $(TARGET_KERNEL_WARNING_CCFLAGS) ;
+		TARGET_WARNING_CCFLAGS_$(TARGET_PACKAGING_ARCH) on $(object)
-		TARGET_WARNING_C++FLAGS on $(object)
+			= $(TARGET_KERNEL_WARNING_CCFLAGS) ;
+		TARGET_WARNING_C++FLAGS_$(TARGET_PACKAGING_ARCH) on $(object)
 			= $(TARGET_KERNEL_WARNING_C++FLAGS) ;
 	}
 }
@@ -40,7 +41,7 @@ rule BootLd
 {
 	# BootLd <name> : <objs> : <linkerscript> : <args> ;
 
-	LINK on $(1) = $(TARGET_LD) ;
+	LINK on $(1) = $(TARGET_LD_$(TARGET_PACKAGING_ARCH)) ;
 
 	LINKFLAGS on $(1) = $(4) ;
 	if $(3) { LINKFLAGS on $(1) += --script=$(3) ; }
@@ -125,5 +126,5 @@ actions BootStaticLibraryObjects
 	# Force recreation of the archive to avoid build errors caused by
 	# stale dependencies after renaming or deleting object files.
 	$(RM) "$(1)"
-	$(HAIKU_AR) -r "$(1)" "$(2)" ;
+	$(HAIKU_AR_$(TARGET_PACKAGING_ARCH)) -r "$(1)" "$(2)" ;
 }

build/jam/BuildFeatureRules

@@ -0,0 +1,455 @@
+rule FQualifiedBuildFeatureName features
+{
+	# FQualifiedBuildFeatureName <features>
+	#
+	# Prepends the name of the current target packaging architecture to the
+	# given feature names.
+
+	return $(TARGET_PACKAGING_ARCH):$(features) ;
+}
+
+
+rule FIsBuildFeatureEnabled feature
+{
+	# FIsBuildFeatureEnabled <feature> ;
+	# Returns whether the given build feature <feature> is enabled (if so: "1",
+	# if not: empty list).
+	#
+	# <feature> - The name of the build feature (all lower case).
+
+	feature = [ FQualifiedBuildFeatureName $(feature) ] ;
+	return $(HAIKU_BUILD_FEATURE_$(feature:U)_ENABLED) ;
+}
+
+
+rule FMatchesBuildFeatures specification
+{
+	# FMatchesBuildFeatures <specification> ;
+	# Returns whether the given build feature specification <specification>
+	# holds. <specification> consists of positive and negative build feature
+	# conditions. Conditions can be individual list elements and multiple
+	# conditions can be joined, separated by ",", in a single list element. The
+	# effect is the same; they are considered as single set of conditions.
+	# A positive condition does not start with a "!". It holds when the build
+	# feature named by the element is enabled.
+	# A negative condition starts with a "!". It holds when the build feature
+	# named by the string resulting from removing the leading "!" is not
+	# enabled.
+	# <specification> holds when it is not empty and
+	# * none of the negative conditions it contains hold and
+	# * if it contains any positive conditions, at least one one of them holds.
+	#
+	# <specification> - The build feature specification. A list of individual
+	#	conditions or conditions joined by ",".
+
+	local splitSpecification ;
+	local element ;
+	for element in $(specification) {
+		splitSpecification += [ FSplitString $(element) : "," ] ;
+	}
+	return [ FConditionsHold $(splitSpecification) : FIsBuildFeatureEnabled ] ;
+}
+
+
+rule FFilterByBuildFeatures list
+{
+	# FFilterByBuildFeatures <list> ;
+	# Filters the list annotated by build feature specifications and returns the
+	# resulting list. The list can be annotated in two different ways:
+	# * A single list element can be annotated by appending "@<specification>"
+	#   to it, with <specification> being a build feature specification (a
+	#   single comma-separated string). The element appears in the resulting
+	#   list, only if <specification> holds.
+	# * A sublist can be annotated by enclosing it in "<specification> @{" (two
+	#   separate list elements) and "}@", with <specification> being a build
+	#   feature specification (a single comma-separated string). The enclosed
+	#   sublist appears in the resulting list, only if <specification> holds.
+	# The sublist annotations can be nested. The annotations themselves don't
+	# appear in the resulting list.
+	#
+	# <list> - A list annotated with build feature specifications.
+
+	local filteredList ;
+
+	# Since we must look ahead one element to be able to decide whether an
+	# element is a regular list element or a features specification for a
+	# subsequent "@{". Hence we always process an element other than "@{" and
+	# "}@" in the next iteration. We append a dummy element to the list so we
+	# don't need special handling for the last element.
+	local evaluationStack = 1 ;
+	local previousElement ;
+	local element ;
+	for element in $(list) dummy {
+		local stackTop = $(evaluationStack[1]) ;
+		local processElement = $(previousElement) ;
+		switch $(element) {
+			case }@ :
+			{
+				# Pop the topmost specification off the stack.
+				evaluationStack = $(evaluationStack[2-]) ;
+				if ! $(evaluationStack) {
+					Exit "FFilterByBuildFeatures: Unbalanced @( in: " $(list) ;
+				}
+
+				processElement = $(previousElement) ;
+				previousElement = ;
+			}
+			case @{ :
+			{
+				if ! $(previousElement) {
+					Exit "FFilterByBuildFeatures: No feature specification"
+						"after )@ in: " $(list) ;
+				}
+
+				if $(evaluationStack[1]) = 1
+					&& [ FMatchesBuildFeatures $(previousElement) ] {
+					evaluationStack = 1 $(evaluationStack) ;
+				} else {
+					evaluationStack = 0 $(evaluationStack) ;
+				}
+
+				processElement = ;
+				previousElement = ;
+			}
+			case * :
+			{
+				processElement = $(previousElement) ;
+				previousElement = $(element) ;
+			}
+		}
+
+		if $(processElement) && $(stackTop) = 1 {
+			local splitElement = [ Match "(.*)@([^@]*)" : $(processElement) ] ;
+			if $(splitElement) {
+				if [ FMatchesBuildFeatures $(splitElement[2]) ] {
+					filteredList += $(splitElement[1]) ;
+				}
+			} else {
+				filteredList += $(processElement) ;
+			}
+		}
+	}
+
+	if $(evaluationStack[2-]) {
+		Exit "FFilterByBuildFeatures: Unbalanced )@ in: " $(list) ;
+	}
+
+	return $(filteredList) ;
+}
+
+
+rule EnableBuildFeatures features : specification
+{
+	# EnableBuildFeatures <features> : <specification> ;
+	# Enables the build features <features>, if the build features specification
+	# <specification> holds. If <specification> is omitted, the features are
+	# enabled unconditionally.
+	# The rule enables a build feature by adding its given lower case name to
+	# the build variable HAIKU_BUILD_FEATURES and defining a build variable
+	# HAIKU_BUILD_FEATURE_<FEATURE>_ENABLED (<FEATURE> being the upper case name
+	# of the build feature) to "1".
+	#
+	# <features> - A list of build feature names (lower case).
+	# <specification> - An optional build features specification (cf.
+	#	FMatchesBuildFeatures).
+
+	features = [ FQualifiedBuildFeatureName $(features) ] ;
+
+	if ! $(HAIKU_BUILD_FEATURE_$(feature:U)_ENABLED)
+		&& ( ! $(specification)
+			|| [ FMatchesBuildFeatures $(specification) ] ) {
+		local feature ;
+		for feature in $(features) {
+			HAIKU_BUILD_FEATURES += $(feature) ;
+			HAIKU_BUILD_FEATURE_$(feature:U)_ENABLED = 1 ;
+		}
+	}
+}
+
+
+rule BuildFeatureObject feature
+{
+	# BuildFeatureObject <feature> ;
+	# Returns a unique object for the given build feature. It is used for
+	# attaching attribute values to it.
+
+	feature = [ FQualifiedBuildFeatureName $(feature) ] ;
+
+	local featureObject = $(HAIKU_BUILD_FEATURE_$(feature:U)) ;
+	if ! $(featureObject) {
+		featureObject = [ NewUniqueTarget ] ;
+		HAIKU_BUILD_FEATURE_$(feature:U) = $(featureObject) ;
+	}
+
+	return $(featureObject) ;
+}
+
+
+rule SetBuildFeatureAttribute feature : attribute : values : package
+{
+	# SetBuildFeatureAttribute <feature> : <attribute> : <values>
+	#	[ : <package> ] ;
+	# Sets attribute <attribute> of a build feature <feature> to value <values>.
+	# If <package> is specified, it names the package the attribute belongs to.
+
+	local featureObject = [ BuildFeatureObject $(feature) ] ;
+	HAIKU_ATTRIBUTE_$(attribute) on $(featureObject) = $(values) ;
+	if $(package) {
+		HAIKU_ATTRIBUTE_$(attribute):package on $(featureObject) = $(package) ;
+	}
+}
+
+
+rule BuildFeatureAttribute feature : attribute : flags
+{
+	# BuildFeatureAttribute <feature> : <attribute> [ : <flags> ] ;
+	# Returns the value of attribute <attribute> of a build feature <feature>.
+	# Flags can be a list of flags which influence the returned value. Currently
+	# only flag "path" is defined, which will convert the attribute value --
+	# which is assumed to be a list of (gristed) targets with a path relative to
+	# the extraction directory of the build feature archive files -- to paths.
+	# A typical example is the "headers" attribute, whose value can be used as
+	# dependency, but which must be converted to a path to be a valid headers
+	# search path.
+
+	local featureObject = [ BuildFeatureObject $(feature) ] ;
+	local values
+		= [ on $(featureObject) return $(HAIKU_ATTRIBUTE_$(attribute)) ] ;
+	if path in $(flags) {
+		# get the attribute's package and the corresponding extraction dir
+		local package
+			= [ BuildFeatureAttribute $(feature) : $(attribute):package ] ;
+		local directory ;
+		if $(package) {
+			directory = [ BuildFeatureAttribute $(feature)
+				: $(package):directory ] ;
+		}
+
+		# translate the values
+		local paths ;
+		local value ;
+		for value in $(values:G=) {
+			paths += [ FDirName $(directory) $(value) ] ;
+		}
+		values = $(paths) ;
+	}
+
+	return $(values) ;
+}
+
+
+rule ExtractBuildFeatureArchivesExpandValue value : fileName
+{
+	if ! $(value) {
+		return $(value) ;
+	}
+
+	# split the value
+	local splitValue ;
+	while $(value) {
+		local components = [ Match "([^%]*)(%[^%]*%)(.*)" : $(value) ] ;
+		if ! $(components) {
+			splitValue += $(value) ;
+			break ;
+		}
+
+		if $(components[1]) {
+			splitValue += $(components[1]) ;
+		}
+		splitValue += $(components[2]) ;
+		value = $(components[3]) ;
+	}
+
+	# reassemble the value, performing the substitutions
+	local %packageName% ;
+	local %portName% ;
+	local %packageFullVersion% ;
+	value = "" ;
+	while $(splitValue) {
+		local component = $(splitValue[1]) ;
+		splitValue = $(splitValue[2-]) ;
+		switch $(component) {
+			case %packageRevisionedName% :
+				splitValue = %packageName% "-" %packageFullVersion%
+					$(splitValue) ;
+
+			case %portRevisionedName% :
+				splitValue = %portName% "-" %packageFullVersion% $(splitValue) ;
+
+			case %*% :
+				if ! x$(%packageName%) {
+					# extract package name and version from file name
+					local splitName
+						= [ Match "([^-]*)-(.*).hpkg" : $(fileName) ] ;
+					if $(splitName) {
+						%packageName% = $(splitName[1]) ;
+						%packageFullVersion%
+							= [ Match "([^-]*-[^-]*)-.*" : $(splitName[2]) ] ;
+						if ! $(packageFullVersion%) {
+							packageFullVersion% = $(splitName[2]) ;
+						}
+					} else {
+						%packageName% = [ Match "(.*).hpkg" : $(fileName) ] ;
+						if ! $(%packageName%) {
+							%packageName% = $(fileName) ;
+						}
+						%packageFullVersion% = "" ;
+					}
+
+					# get the port name from the package name
+					splitName = [ FSplitPackageName $(%packageName%) ] ;
+					%portName% = $(splitName[1]) ;
+				}
+
+				value = "$(value)$($(component):E=)" ;
+
+			case * :
+				value = "$(value)$(component)" ;
+		}
+	}
+
+	return $(value) ;
+}
+
+
+rule ExtractBuildFeatureArchives feature : list
+{
+	# ExtractBuildFeatureArchives <feature> : <list> ;
+	# Downloads and extracts one or more archives for build feature <feature>
+	# and sets attributes for the build feature to extracted entries. The syntax
+	# for <list> is:
+	# "file:" <packageAlias> <packageName>
+	#    <attribute>: <value> ...
+	#    ...
+	# "file:" <packageAlias2> <packageName2>
+	# ...
+	#
+	# <packageAlias> specifies a short name for the archive (e.g. "base" for the
+	# base package, "devel" for the development package, etc.), <packageName>
+	# the unversioned name of the package (e.g. "libsolv_devel").
+	# <attribute> can be any name and <value> any relative path in the
+	# extraction directory. The following placeholders in <value> will be
+	# replaced with the respective value:
+	# * %packageName% is replaced with the name of the package as extracted from
+	#   the package file name (may differ from the specified package name e.g.
+	#   for bootstrap packages).
+	# * %portName% is replaced with the name of the port the package belongs to.
+	#   That is %packageName% with any well-known package type suffix ("_devel",
+	#   "_source", etc.) removed.
+	# * %packageFullVersion% is replaced with the the full version string of the
+	#   package (i.e. including the revision) as extracted frmo the package file
+	#   name.
+	# * %packageRevisionedName% is replaced with what
+	#   %packageName%-%packageFullVersion% would be replaced.
+	# * %portRevisionedName% is replaced with what
+	#   %portName%-%packageFullVersion% would be replaced.
+	#
+	# The attribute with the name "depends" will be handled specially. Its
+	# <value> specifies the name of a package the current package depends on
+	# (e.g. "devel" typically depends on "base"). If such a dependency is
+	# specified the current package will be extracted to the same directory as
+	# the package it depends on. The "depends" attribute must precede any other
+	# attribute for the package.
+	#
+	# The rule also sets the build feature attribute "<packageAlias>:directory"
+	# to the extraction directory for each package.
+
+	local qualifiedFeature = [ FQualifiedBuildFeatureName $(feature) ] ;
+	list = [ FFilterByBuildFeatures $(list) ] ;
+
+	while $(list) {
+		if $(list[1]) != file: {
+			Exit "ExtractBuildFeatureArchives: Expected \"file: ...\", got:"
+				$(list) ;
+		}
+
+		local package = $(list[2]) ;
+		local file = [ FetchPackage $(list[3]) ] ;
+		local fileName = $(file:BS) ;
+		list = $(list[4-]) ;
+
+		local directory = [ FDirName $(HAIKU_OPTIONAL_BUILD_PACKAGES_DIR)
+			$(fileName:B) ] ;
+		directory = $(directory:G=$(package)) ;
+
+		while $(list) {
+			local attribute = [ Match "(.*):" : $(list[1]) ] ;
+			if ! $(attribute) {
+				Exit "ExtractBuildFeatureArchives: Expected attribute, got:"
+					$(list) ;
+			}
+			if $(attribute) = file {
+				break ;
+			}
+
+			list = $(list[2-]) ;
+
+			local values ;
+
+			while $(list) {
+				switch $(list[1]) {
+					case *: :
+					{
+						break ;
+					}
+					case * :
+					{
+						values += [ ExtractBuildFeatureArchivesExpandValue
+							$(list[1]) : $(fileName) ] ;
+						list = $(list[2-]) ;
+					}
+				}
+			}
+
+			if $(attribute) = depends {
+				# Inherit the extraction directory (with a different grist) and
+				# depend on the extraction directory of the base package.
+				local basePackage = $(values[1]) ;
+				local baseDirectory = [ BuildFeatureAttribute $(feature)
+					: $(basePackage):directory ] ;
+				directory = $(baseDirectory:G=$(package)) ;
+				Depends $(directory) : $(directory:G=$(basePackage)) ;
+			} else {
+				SetBuildFeatureAttribute $(feature) : $(attribute)
+					: [ ExtractArchive $(directory)
+						: $(values) : $(file)
+						: extracted-$(qualifiedFeature)-$(package) ] ;
+				SetBuildFeatureAttribute $(feature) : $(attribute):package
+					: $(package) ;
+			}
+		}
+
+		SetBuildFeatureAttribute $(feature) : $(package):directory
+			: $(directory:G=) ;
+	}
+}
+
+
+rule InitArchitectureBuildFeatures architecture
+{
+	# InitArchitectureBuildFeatures <architecture> ;
+	#
+	# Enable the build features that can be derived directly from the
+	# architecture.
+
+	# The build feature rule use TARGET_PACKAGING_ARCH, so set that temporarily.
+	local savedArchitecture = $(TARGET_PACKAGING_ARCH) ;
+	TARGET_PACKAGING_ARCH = $(architecture) ;
+
+	# Add the target architecture as a build feature.
+	EnableBuildFeatures $(TARGET_ARCH_$(architecture)) ;
+
+	# For the primary architecture add the "primary" build feature.
+	if $(architecture) = $(TARGET_PACKAGING_ARCHS[1]) {
+		EnableBuildFeatures primary ;
+	}
+
+	# Add all secondary architectures as build features (with prefix).
+	EnableBuildFeatures secondary_$(TARGET_PACKAGING_ARCHS[2-]) ;
+
+	if $(TARGET_GCC_VERSION_$(architecture)[1]) = 2 {
+		EnableBuildFeatures gcc2 ;
+	}
+
+	TARGET_PACKAGING_ARCH = $(savedArchitecture) ;
+}

build/jam/BuildFeatures

@@ -1,75 +1,37 @@
-# This file contains setup for build features that are not available for all
+# This file contains setup for build features that require external packages. It
-# architectures/setups or that are optional for the build. For features that
+# is included once for each configured packaging architecture (with
-# require downloading a zip file from somewhere it is likely the same file used
+# TARGET_PACKAGING_ARCH set accordingly).
-# for an optional package.
 
 
-# Add the target architecture as a build feature.
+local architecture = $(TARGET_PACKAGING_ARCH) ;
-EnableBuildFeatures $(HAIKU_ARCH) ;
+local secondaryArchSubDir = [ MultiArchIfPrimary "" : /$(architecture) ] ;
-
+local developLibDir = develop/lib$(secondaryArchSubDir) ;
-
+local developHeadersDir = develop/headers$(secondaryArchSubDir) ;
-# Detect a hybrid GCC2/GCC4 image and disable the checks for unavailable GCC4
-# packages. (It does not matter if a package was built with either compiler,
-# the system should have the respective other system libs.)
-local isHybridBuild ;
-if $(HAIKU_ADD_ALTERNATIVE_GCC_LIBS) = 1
-		&& $(HAIKU_ALTERNATIVE_GCC_OUTPUT_DIR) {
-	isHybridBuild = 1 ;
-}
-
-local baseURL = http://www.haiku-files.org/files/optional-packages ;
 
 
 # SSL
 
-# Automatically enable the SSL feature, when the optional OpenSSL optional
+# Automatically enable the SSL feature, when the OpenSSL package is enabled.
-# package is enabled.
+if [ IsHaikuImagePackageAdded openssl ] {
-if [ IsOptionalHaikuImagePackageAdded OpenSSL ] {
 	HAIKU_BUILD_FEATURE_SSL = 1 ;
 }
 
-if $(HAIKU_GCC_VERSION[1]) >= 4 {
-	if $(TARGET_ARCH) = x86_64 {
-		HAIKU_OPENSSL_PACKAGE = openssl-1.0.0j-x86_64-2012-12-18.zip ;
-	} else {
-		HAIKU_OPENSSL_PACKAGE = openssl-1.0.0j-r1a4-x86-gcc4-2012-08-29.zip ;
-	}
-} else {
-	HAIKU_OPENSSL_PACKAGE = openssl-1.0.0j-r1a4-x86-gcc2-2012-08-26.zip ;
-}
-
-HAIKU_OPENSSL_URL = $(baseURL)/$(HAIKU_OPENSSL_PACKAGE) ;
-
 if $(HAIKU_BUILD_FEATURE_SSL) {
-	if $(TARGET_ARCH) = x86 || $(TARGET_ARCH) = x86_64 {
+	if [ IsPackageAvailable openssl_devel ] {
-		# Download the zip archive.
+		ExtractBuildFeatureArchives openssl :
-		local zipFile = [ DownloadFile $(HAIKU_OPENSSL_PACKAGE)
+			file: base openssl
-			: $(HAIKU_OPENSSL_URL) ] ;
+				runtime: lib
-
+			file: devel openssl_devel
-		# zip file and output directory
+				depends: base
-		HAIKU_OPENSSL_ZIP_FILE = $(zipFile) ;
+				libraries:
-		HAIKU_OPENSSL_DIR = [ FDirName $(HAIKU_OPTIONAL_BUILD_PACKAGES_DIR)
+					$(developLibDir)/libcrypto.so
-			$(HAIKU_OPENSSL_PACKAGE:B) ] ;
+					$(developLibDir)/libssl.so
-
+				headers: $(developHeadersDir)
-		# extract headers and libraries
+			;
-		HAIKU_OPENSSL_HEADERS_DEPENDENCY = [ ExtractArchive $(HAIKU_OPENSSL_DIR)
-			: common/include/ : $(zipFile) : extracted-openssl
-		] ;
-
-		HAIKU_OPENSSL_LIBS = [ ExtractArchive $(HAIKU_OPENSSL_DIR)
-			:
-			common/lib/libcrypto.so
-			common/lib/libssl.so
-			: $(zipFile)
-			: extracted-openssl
-		] ;
-
-		HAIKU_OPENSSL_HEADERS
-			= [ FDirName $(HAIKU_OPENSSL_DIR) common include ] ;
 
 		EnableBuildFeatures openssl ;
 	} else {
-		Echo "SSL build feature not available for $(TARGET_ARCH)" ;
+		Echo "SSL build feature not available for $(TARGET_PACKAGING_ARCH)" ;
 	}
 }
 
@@ -77,92 +39,37 @@ if $(HAIKU_BUILD_FEATURE_SSL) {
 # ICU
 
 # Note ICU isn't actually optional, but is still an external package
-HAIKU_ICU_GCC_2_PACKAGE = icu-4.8.1.1-r1a4-x86-gcc2-2012-08-29.zip ;
+if [ IsPackageAvailable icu_devel ] {
-HAIKU_ICU_GCC_4_PACKAGE = icu-4.8.1.1-r1a4-x86-gcc4-2012-08-29.zip ;
+	ExtractBuildFeatureArchives icu :
-HAIKU_ICU_PPC_PACKAGE = icu-4.8.1-ppc-2011-08-20.zip ;
+		file: base icu
-HAIKU_ICU_ARM_PACKAGE = icu-4.8.1.1-arm-2012-11-21.zip ;
+			runtime: lib
-HAIKU_ICU_X86_64_PACKAGE = icu-4.8.1.1-x86_64-2012-07-30.zip ;
+		file: devel icu_devel
-
+			depends: base
-if $(TARGET_ARCH) in arm ppc x86 x86_64 {
+			libraries:
-	local icu_package ;
+				$(developLibDir)/libicudata.so
-	if $(TARGET_ARCH) = ppc {
+				$(developLibDir)/libicui18n.so
-		icu_package = $(HAIKU_ICU_PPC_PACKAGE) ;
+				$(developLibDir)/libicuio.so
-		HAIKU_ICU_DEVEL_PACKAGE = icu-devel-4.8.1-ppc-2011-12-19.zip ;
+				$(developLibDir)/libicule.so
-	} else if $(TARGET_ARCH) = arm {
+				$(developLibDir)/libiculx.so
-		icu_package = $(HAIKU_ICU_ARM_PACKAGE) ;
+				$(developLibDir)/libicutu.so
-		HAIKU_ICU_DEVEL_PACKAGE = icu-devel-4.8.1.1-arm-2012-11-21.zip ;
+				$(developLibDir)/libicuuc.so
-	} else if $(TARGET_ARCH) = x86_64 {
+			headers: $(developHeadersDir)
-		icu_package = $(HAIKU_ICU_X86_64_PACKAGE) ;
+		;
-		HAIKU_ICU_DEVEL_PACKAGE = icu-devel-4.8.1.1-x86_64-2012-07-30.zip ;
-	} else if $(HAIKU_GCC_VERSION[1]) = 2 {
-		icu_package = $(HAIKU_ICU_GCC_2_PACKAGE) ;
-		HAIKU_ICU_DEVEL_PACKAGE = icu-devel-4.8.1.1-x86-gcc2-2011-12-20.zip ;
-	} else {
-		icu_package = $(HAIKU_ICU_GCC_4_PACKAGE) ;
-		HAIKU_ICU_DEVEL_PACKAGE = icu-devel-4.8.1.1-x86-gcc4-2011-12-20.zip ;
-	}
-	local zipFile = [ DownloadFile $(icu_package)
-		: $(baseURL)/$(icu_package) ] ;
-
-	# zip file and output directory
-	HAIKU_ICU_ZIP_FILE = $(zipFile) ;
-	HAIKU_ICU_DIR = [ FDirName $(HAIKU_OPTIONAL_BUILD_PACKAGES_DIR)
-		$(icu_package:B) ] ;
-
-	# extract libraries
-	if $(TARGET_ARCH) = ppc {
-		HAIKU_ICU_LIBS = [ ExtractArchive $(HAIKU_ICU_DIR)
-			:
-			libicudata.so.48.1
-			libicui18n.so.48.1
-			libicuio.so.48.1
-			libicule.so.48.1
-			libiculx.so.48.1
-			libicutu.so.48.1
-			libicuuc.so.48.1
-			: $(zipFile)
-			: extracted-icu
-		] ;
-	} else {
-		HAIKU_ICU_LIBS = [ ExtractArchive $(HAIKU_ICU_DIR)
-			:
-			libicudata.so.48.1.1
-			libicui18n.so.48.1.1
-			libicuio.so.48.1.1
-			libicule.so.48.1.1
-			libiculx.so.48.1.1
-			libicutu.so.48.1.1
-			libicuuc.so.48.1.1
-			: $(zipFile)
-			: extracted-icu
-		] ;
-	}
-
-	# zip file and output directory
-	HAIKU_ICU_DEVEL_ZIP_FILE = [ DownloadFile $(HAIKU_ICU_DEVEL_PACKAGE)
-			: $(baseURL)/$(HAIKU_ICU_DEVEL_PACKAGE) ] ;
-	HAIKU_ICU_DEVEL_DIR = [ FDirName $(HAIKU_OPTIONAL_BUILD_PACKAGES_DIR)
-		$(HAIKU_ICU_DEVEL_PACKAGE:B) ] ;
-
-	# extract headers
-	HAIKU_ICU_HEADERS_DEPENDENCY = [ ExtractArchive $(HAIKU_ICU_DEVEL_DIR)
-		: develop/headers/3rdparty : $(HAIKU_ICU_DEVEL_ZIP_FILE)
-		: extracted-icu-devel ] ;
-
-	HAIKU_ICU_HEADERS
-		= [ FDirName $(HAIKU_ICU_DEVEL_DIR) develop headers 3rdparty ] ;
 
 	EnableBuildFeatures icu ;
 } else  {
-	Echo "ICU not available for $(TARGET_ARCH)" ;
+	Echo "ICU not available for $(TARGET_PACKAGING_ARCH)" ;
 }
 
 
 # CLucene
 
-# Automatically install the CLucene feature, when the optional CLucene optional
+# TODO: Update to packages!
-# package is enabled.
+if ! 1 {
-if [ IsOptionalHaikuImagePackageAdded CLucene ] {
+
+# Automatically install the CLucene feature, when the CLucene package is
+# enabled.
+if [ IsHaikuImagePackageAdded clucene ] {
 	HAIKU_BUILD_FEATURE_CLUCENE = 1 ;
 }
 
@@ -172,7 +79,8 @@ HAIKU_CLUCENE_URL = $(baseURL)/$(HAIKU_CLUCENE_PACKAGE) ;
 
 if $(HAIKU_BUILD_FEATURE_CLUCENE) {
 	if $(TARGET_ARCH) != x86 {
-		Echo "CLucene build feature not available for $(TARGET_ARCH)" ;
+		Echo "CLucene build feature not available for"
+			"$(TARGET_PACKAGING_ARCH)" ;
 	} else {
 		# Download the zip archive.
 		local zipFile = [ DownloadFile $(HAIKU_CLUCENE_PACKAGE)
@@ -202,301 +110,226 @@ if $(HAIKU_BUILD_FEATURE_CLUCENE) {
 	}
 }
 
+} # ! 1
+
+
+# TODO: Update to packages!
+if ! 1 {
+
+# LLVM
+if $(TARGET_ARCH) = x86 {
+	if $(TARGET_GCC_VERSION_$(architecture)[1]) >= 4 {
+		HAIKU_LLVM_FILE = llvm-3.2-x86-gcc4-2012-12-21.zip ;
+		local zipFile = [ DownloadFile $(HAIKU_LLVM_FILE)
+			: $(baseURL)/$(HAIKU_LLVM_FILE) ] ;
+
+		HAIKU_LLVM_DIR = [ FDirName $(HAIKU_OPTIONAL_BUILD_PACKAGES_DIR)
+			$(HAIKU_LLVM_FILE:B) ] ;
+
+		HAIKU_LLVM_HEADERS_DEPENDENCY = [ ExtractArchive $(HAIKU_LLVM_DIR)
+			: common/include/ : $(zipFile) : extracted-llvm ] ;
+		HAIKU_LLVM_HEADERS = [ FDirName $(HAIKU_LLVM_DIR) common include ] ;
+
+		# We can't Glob these because they aren't extracted yet.
+		HAIKU_LLVM_LIBS = [ ExtractArchive $(HAIKU_LLVM_DIR)
+			:
+			common/lib/libLLVMAsmParser.a
+			common/lib/libLLVMInstrumentation.a
+			common/lib/libLLVMLinker.a
+			common/lib/libLLVMArchive.a
+			common/lib/libLLVMBitReader.a
+			common/lib/libLLVMDebugInfo.a
+			common/lib/libLLVMJIT.a
+			common/lib/libLLVMipo.a
+			common/lib/libLLVMVectorize.a
+			common/lib/libLLVMBitWriter.a
+			common/lib/libLLVMTableGen.a
+			#common/lib/libLLVMHexagonCodeGen.a
+			#common/lib/libLLVMHexagonAsmPrinter.a
+			#common/lib/libLLVMHexagonDesc.a
+			#common/lib/libLLVMHexagonInfo.a
+			#common/lib/libLLVMNVPTXCodeGen.a
+			#common/lib/libLLVMNVPTXDesc.a
+			#common/lib/libLLVMNVPTXInfo.a
+			#common/lib/libLLVMNVPTXAsmPrinter.a
+			#common/lib/libLLVMMBlazeCodeGen.a
+			#common/lib/libLLVMMBlazeAsmParser.a
+			#common/lib/libLLVMMBlazeDisassembler.a
+			#common/lib/libLLVMMBlazeDesc.a
+			#common/lib/libLLVMMBlazeInfo.a
+			#common/lib/libLLVMMBlazeAsmPrinter.a
+			common/lib/libLLVMCppBackendCodeGen.a
+			common/lib/libLLVMCppBackendInfo.a
+			#common/lib/libLLVMMSP430CodeGen.a
+			#common/lib/libLLVMMSP430Desc.a
+			#common/lib/libLLVMMSP430AsmPrinter.a
+			#common/lib/libLLVMMSP430Info.a
+			#common/lib/libLLVMXCoreCodeGen.a
+			#common/lib/libLLVMXCoreDesc.a
+			#common/lib/libLLVMXCoreInfo.a
+			#common/lib/libLLVMCellSPUCodeGen.a
+			#common/lib/libLLVMCellSPUDesc.a
+			#common/lib/libLLVMCellSPUInfo.a
+			#common/lib/libLLVMMipsAsmParser.a
+			#common/lib/libLLVMMipsCodeGen.a
+			#common/lib/libLLVMMipsDesc.a
+			#common/lib/libLLVMMipsAsmPrinter.a
+			#common/lib/libLLVMMipsDisassembler.a
+			#common/lib/libLLVMMipsInfo.a
+			#common/lib/libLLVMARMAsmParser.a
+			#common/lib/libLLVMARMCodeGen.a
+			#common/lib/libLLVMARMDisassembler.a
+			#common/lib/libLLVMARMDesc.a
+			#common/lib/libLLVMARMInfo.a
+			#common/lib/libLLVMARMAsmPrinter.a
+			#common/lib/libLLVMPowerPCCodeGen.a
+			#common/lib/libLLVMPowerPCDesc.a
+			#common/lib/libLLVMPowerPCInfo.a
+			#common/lib/libLLVMPowerPCAsmPrinter.a
+			#common/lib/libLLVMSparcCodeGen.a
+			#common/lib/libLLVMSparcDesc.a
+			#common/lib/libLLVMSparcInfo.a
+			common/lib/libLLVMX86AsmParser.a
+			common/lib/libLLVMX86CodeGen.a
+			common/lib/libLLVMSelectionDAG.a
+			common/lib/libLLVMAsmPrinter.a
+			common/lib/libLLVMX86Disassembler.a
+			common/lib/libLLVMX86Desc.a
+			common/lib/libLLVMX86Info.a
+			common/lib/libLLVMX86AsmPrinter.a
+			common/lib/libLLVMX86Utils.a
+			common/lib/libLLVMMCDisassembler.a
+			common/lib/libLLVMMCParser.a
+			common/lib/libLLVMInterpreter.a
+			common/lib/libLLVMCodeGen.a
+			common/lib/libLLVMScalarOpts.a
+			common/lib/libLLVMInstCombine.a
+			common/lib/libLLVMTransformUtils.a
+			common/lib/libLLVMipa.a
+			common/lib/libLLVMAnalysis.a
+			common/lib/libLLVMMCJIT.a
+			common/lib/libLLVMRuntimeDyld.a
+			common/lib/libLLVMExecutionEngine.a
+			common/lib/libLLVMTarget.a
+			common/lib/libLLVMMC.a
+			common/lib/libLLVMObject.a
+			common/lib/libLLVMCore.a
+			common/lib/libLLVMSupport.a
+			: $(zipFile) : extracted-llvm ]
+		;
+
+		EnableBuildFeatures llvm ;
+	} else {
+		# Nor will it ever be
+		Echo "LLVM not available on GCC2" ;
+	}
+} else {
+	Echo "LLVM not yet available on $(TARGET_PACKAGING_ARCH)" ;
+}
+
+} # ! 1
+
 
 # GLU (GL Utilities)
-if $(TARGET_ARCH) = x86 {
+if [ IsPackageAvailable glu_devel ] {
-	if $(HAIKU_GCC_VERSION[1]) >= 4 {
+	ExtractBuildFeatureArchives glu :
-		HAIKU_GLU_FILE = glu-9.0-x86-gcc4-2012-11-13.zip ;
+		file: base glu
-	} else {
+			runtime: lib
-		HAIKU_GLU_FILE = glu-9.0-x86-gcc2-2012-11-13.zip ;
+		file: devel glu_devel
-	}
+			depends: base
-
+			library: $(developLibDir)/libGLU.so
-	local zipFile = [ DownloadFile $(HAIKU_GLU_FILE)
+			headers: $(developHeadersDir)
-		: $(baseURL)/lib/$(HAIKU_GLU_FILE) ] ;
+		;
-
-	HAIKU_GLU_DIR = [ FDirName $(HAIKU_OPTIONAL_BUILD_PACKAGES_DIR)
-		$(HAIKU_GLU_FILE:B) ] ;
-	HAIKU_GLU_HEADERS_DEPENDENCY = [ ExtractArchive $(HAIKU_GLU_DIR)
-		: develop/headers/os/opengl/GL : $(zipFile) : extracted-glu-headers ] ;
-	HAIKU_GLU_LIBS = [ ExtractArchive $(HAIKU_GLU_DIR)
-		: system/lib/libGLU.a : $(zipFile) : extracted-glu ] ;
-	HAIKU_GLU_HEADERS = [ FDirName $(HAIKU_GLU_DIR) develop headers os opengl ] ;
 
 	EnableBuildFeatures glu ;
 } else {
-	Echo "GLU not yet available on $(TARGET_ARCH)" ;
+	Echo "GLU not yet available on $(TARGET_PACKAGING_ARCH)" ;
 }
 
 
 # Mesa
-if $(TARGET_ARCH) = x86 {
+if [ IsPackageAvailable mesa_devel ] {
-	local zipFile ;
+	ExtractBuildFeatureArchives mesa : [ FFilterByBuildFeatures
-	if $(HAIKU_GCC_VERSION[1]) >= 4 {
+		file: devel mesa_devel
-		HAIKU_MESA_FILE = mesa-9.2.0-x86-gcc4-2013-08-28.zip ;
+			mesaLibrary: $(developLibDir)/libmesa.a
-	} else {
+			glapiLibrary: $(developLibDir)/libglapi.a
-		HAIKU_MESA_FILE = mesa-7.8.2-x86-gcc2-2013-04-28.zip ;
+			headers: $(developHeadersDir)
-	}
+			privateHeaders: $(developHeadersDir)/mesa_private
 
-	zipFile = [ DownloadFile $(HAIKU_MESA_FILE)
+			!gcc2 @{
-		: $(baseURL)/$(HAIKU_MESA_FILE) ] ;
+				glslLibrary: $(developLibDir)/libglsl.a
+				galliumLibrary: $(developLibDir)/libgallium.a
+				llvm @{
+					galliumLlvmpipeLibrary: $(developLibDir)/libllvmpipe.a
+				}@
+				!llvm @{
+					galliumSoftpipeLibrary: $(developLibDir)/libsoftpipe.a
+				}@
+			}@ # !gcc2
+		] ;
 
-	HAIKU_MESA_DIR = [ FDirName $(HAIKU_OPTIONAL_BUILD_PACKAGES_DIR)
+	Depends [ BuildFeatureAttribute mesa : galliumLlvmpipeLibrary ]
-		$(HAIKU_MESA_FILE:B) ] ;
+		: $(HAIKU_LLVM_LIBS) ;
-
-	HAIKU_MESA_HEADERS = [ FDirName $(HAIKU_MESA_DIR) include ] ;
-	HAIKU_MESA_HEADERS_DEPENDENCY = [ ExtractArchive $(HAIKU_MESA_DIR)
-		: include/ : $(zipFile) : extracted-mesa ] ;
-
-	# Base Mesa libraries
-	HAIKU_MESA_LIB = [ ExtractArchive $(HAIKU_MESA_DIR)
-		:
-		lib.haiku/libmesa.a
-		: $(zipFile)
-		: extracted-mesa ] ;
-	HAIKU_GLAPI_LIB = [ ExtractArchive $(HAIKU_MESA_DIR)
-		:
-		lib.haiku/libglapi.a
-		: $(zipFile)
-		: extracted-mesa ] ;
-
-	Depends $(HAIKU_MESA_HEADERS_DEPENDENCY) : $(HAIKU_GLU_HEADERS_DEPENDENCY) ;
-	Depends $(HAIKU_GLAPI_LIBS) : $(HAIKU_GLU_LIBS) ;
-
-	# Extended Mesa libraries for newer versions
-	if $(HAIKU_GCC_VERSION[1]) >= 4 {
-		HAIKU_GLSL_LIB = [ ExtractArchive $(HAIKU_MESA_DIR)
-			:
-			lib.haiku/libglsl.a
-			: $(zipFile)
-			: extracted-mesa ] ;
-		HAIKU_GALLIUM_LIB = [ ExtractArchive $(HAIKU_MESA_DIR)
-			:
-			lib.haiku/libgallium.a
-			: $(zipFile)
-			: extracted-mesa ] ;
-		HAIKU_GALLIUM_SWPIPE_LIB = [ ExtractArchive $(HAIKU_MESA_DIR)
-			:
-			lib.haiku/swpipe_bundle.a
-			: $(zipFile)
-			: extracted-mesa ] ;
-	}
 
 	EnableBuildFeatures mesa ;
 } else {
-	Echo "Mesa 3D rendering support not available on $(TARGET_ARCH)" ;
+	Echo "Mesa 3D rendering support not available on $(TARGET_PACKAGING_ARCH)" ;
 }
 
 
 # FFmpeg
-local ffmpegBaseURL = $(baseURL)/lib ;
+if [ IsPackageAvailable ffmpeg_devel ] {
-if $(TARGET_ARCH) = x86 {
+	local ffmpegLibs = libavformat.so libavcodec.so libavdevice.so
-	if $(HAIKU_GCC_VERSION[1]) >= 4 {
+		libavfilter.so libswscale.so libavutil.so ;
-		HAIKU_FFMPEG_FILE = ffmpeg-0.10.2-r1a4-x86-gcc4-2012-09-02.zip ;
+	local speexLibs = libspeex.so ;
-		HAIKU_SPEEX_FILE = speex-1.2rc1-r1a4-x86-gcc4-2012-09-02.zip ;
+	local libtheoraLibs = libtheora.so libtheoradec.so libtheoraenc.so ;
-		HAIKU_LIBTHEORA_FILE = libtheora-1.1.1-r1a4-x86-gcc4-2012-09-02.zip ;
+	local libvorbisLibs = libvorbis.so libvorbisenc.so ;
-		HAIKU_LIBVORBIS_FILE = libvorbis-1.3.2-r1a4-x86-gcc4-2012-09-02.zip ;
+	local liboggLibs = libogg.so ;
-		HAIKU_LIBOGG_FILE = libogg-1.3.0-r1a4-x86-gcc4-2012-09-02.zip ;
+	local libvpxLibs = libvpx.so ;
-		HAIKU_LIBVPX_FILE = libvpx-1.0.0-r1a4-x86-gcc4-2012-09-02.zip ;
+
-	} else {
+	local feature ;
-		HAIKU_FFMPEG_FILE = ffmpeg-0.10.2-r1a4-x86-gcc2-2012-08-30.zip ;
+	for feature in ffmpeg speex libtheora libvorbis libogg libvpx {
-		HAIKU_SPEEX_FILE = speex-1.2rc1-r1a4-x86-gcc2-2012-08-29.zip ;
+		ExtractBuildFeatureArchives $(feature) :
-		HAIKU_LIBTHEORA_FILE = libtheora-1.1.1-r1a4-x86-gcc2-2012-08-29.zip ;
+			file: base $(feature)
-		HAIKU_LIBVORBIS_FILE = libvorbis-1.3.2-r1a4-x86-gcc2-2012-08-29.zip ;
+				runtime: lib
-		HAIKU_LIBOGG_FILE = libogg-1.3.0-r1a4-x86-gcc2-2012-08-29.zip ;
+			file: devel $(feature)_devel
-		HAIKU_LIBVPX_FILE = libvpx-1.0.0-r1a4-x86-gcc2-2012-08-29.zip ;
+				depends: base
+				libraries: $(developLibDir)/$($(feature)Libs)
+				headers: $(developHeadersDir)
+			;
+
+		EnableBuildFeatures $(feature) ;
 	}
-
-	local ffmpegZipFile = [ DownloadFile $(HAIKU_FFMPEG_FILE)
-		: $(ffmpegBaseURL)/$(HAIKU_FFMPEG_FILE) ] ;
-	local speexZipFile = [ DownloadFile $(HAIKU_SPEEX_FILE)
-		: $(ffmpegBaseURL)/$(HAIKU_SPEEX_FILE) ] ;
-	local libtheoraZipFile = [ DownloadFile $(HAIKU_LIBTHEORA_FILE)
-		: $(ffmpegBaseURL)/$(HAIKU_LIBTHEORA_FILE) ] ;
-	local libvorbisZipFile = [ DownloadFile $(HAIKU_LIBVORBIS_FILE)
-		: $(ffmpegBaseURL)/$(HAIKU_LIBVORBIS_FILE) ] ;
-	local liboggZipFile = [ DownloadFile $(HAIKU_LIBOGG_FILE)
-		: $(ffmpegBaseURL)/$(HAIKU_LIBOGG_FILE) ] ;
-	local libvpxZipFile = [ DownloadFile $(HAIKU_LIBVPX_FILE)
-		: $(ffmpegBaseURL)/$(HAIKU_LIBVPX_FILE) ] ;
-
-	HAIKU_FFMPEG_DIR = [ FDirName $(HAIKU_OPTIONAL_BUILD_PACKAGES_DIR)
-		$(HAIKU_FFMPEG_FILE:B) ] ;
-	HAIKU_SPEEX_DIR = [ FDirName $(HAIKU_OPTIONAL_BUILD_PACKAGES_DIR)
-		$(HAIKU_SPEEX_FILE:B) ] ;
-	HAIKU_LIBTHEORA_DIR = [ FDirName $(HAIKU_OPTIONAL_BUILD_PACKAGES_DIR)
-		$(HAIKU_LIBTHEORA_FILE:B) ] ;
-	HAIKU_LIBVORBIS_DIR = [ FDirName $(HAIKU_OPTIONAL_BUILD_PACKAGES_DIR)
-		$(HAIKU_LIBVORBIS_FILE:B) ] ;
-	HAIKU_LIBOGG_DIR = [ FDirName $(HAIKU_OPTIONAL_BUILD_PACKAGES_DIR)
-		$(HAIKU_LIBOGG_FILE:B) ] ;
-	HAIKU_LIBVPX_DIR = [ FDirName $(HAIKU_OPTIONAL_BUILD_PACKAGES_DIR)
-		$(HAIKU_LIBVPX_FILE:B) ] ;
-
-	HAIKU_FFMPEG_HEADERS_DEPENDENCY = [ ExtractArchive $(HAIKU_FFMPEG_DIR)
-		: common/include/ : $(ffmpegZipFile) : extracted-ffmpeg ] ;
-	HAIKU_SPEEX_HEADERS_DEPENDENCY = [ ExtractArchive $(HAIKU_SPEEX_DIR)
-		: common/include/ : $(speexZipFile) : extracted-speex ] ;
-	HAIKU_LIBTHEORA_HEADERS_DEPENDENCY = [ ExtractArchive $(HAIKU_LIBTHEORA_DIR)
-		: common/include/ : $(libtheoraZipFile) : extracted-libtheora ] ;
-	HAIKU_LIBVORBIS_HEADERS_DEPENDENCY = [ ExtractArchive $(HAIKU_LIBVORBIS_DIR)
-		: common/include/ : $(libvorbisZipFile) : extracted-libvorbis ] ;
-	HAIKU_LIBOGG_HEADERS_DEPENDENCY = [ ExtractArchive $(HAIKU_LIBOGG_DIR)
-		: common/include/ : $(liboggZipFile) : extracted-libogg ] ;
-	HAIKU_LIBVPX_HEADERS_DEPENDENCY = [ ExtractArchive $(HAIKU_LIBVPX_DIR)
-		: common/include/ : $(libvpxZipFile) : extracted-libvpx ] ;
-
-	HAIKU_FFMPEG_LIBS = [ ExtractArchive $(HAIKU_FFMPEG_DIR)
-		:
-		common/lib/libavformat.a
-		common/lib/libavcodec.a
-		common/lib/libavdevice.a
-		common/lib/libavfilter.a
-		common/lib/libswscale.a
-		common/lib/libavutil.a
-		: $(ffmpegZipFile)
-		: extracted-ffmpeg ] ;
-	Depends $(HAIKU_FFMPEG_LIBS) : $(HAIKU_FFMPEG_HEADERS_DEPENDENCY) ;
-
-	HAIKU_SPEEX_LIBS = [ ExtractArchive $(HAIKU_SPEEX_DIR)
-		:
-		common/lib/libspeex.a
-		: $(speexZipFile)
-		: extracted-speex ] ;
-	Depends $(HAIKU_SPEEX_LIBS) : $(HAIKU_SPEEX_HEADERS_DEPENDENCY) ;
-
-	HAIKU_LIBTHEORA_LIBS = [ ExtractArchive $(HAIKU_LIBTHEORA_DIR)
-		:
-		common/lib/libtheora.a
-		common/lib/libtheoradec.a
-		common/lib/libtheoraenc.a
-		: $(libtheoraZipFile)
-		: extracted-libtheora ] ;
-	Depends $(HAIKU_LIBTHEORA_LIBS) : $(HAIKU_LIBTHEORA_HEADERS_DEPENDENCY) ;
-
-
-	HAIKU_LIBVORBIS_LIBS = [ ExtractArchive $(HAIKU_LIBVORBIS_DIR)
-		:
-		common/lib/libvorbis.a
-		common/lib/libvorbisenc.a
-		: $(libvorbisZipFile)
-		: extracted-libvorbis ] ;
-	Depends $(HAIKU_LIBVORBIS_LIBS) : $(HAIKU_LIBVORBIS_HEADERS_DEPENDENCY) ;
-
-
-	HAIKU_LIBOGG_LIBS = [ ExtractArchive $(HAIKU_LIBOGG_DIR)
-		:
-		common/lib/libogg.a
-		: $(liboggZipFile)
-		: extracted-libogg ] ;
-	Depends $(HAIKU_LIBOGG_LIBS) : $(HAIKU_LIBOGG_HEADERS_DEPENDENCY) ;
-
-	HAIKU_LIBVPX_LIBS = [ ExtractArchive $(HAIKU_LIBVPX_DIR)
-		:
-		common/lib/libvpx.a
-		: $(libvpxZipFile)
-		: extracted-libvpx ] ;
-	Depends $(HAIKU_LIBVPX_LIBS) : $(HAIKU_LIBVPX_HEADERS_DEPENDENCY) ;
-
-	HAIKU_FFMPEG_HEADERS = [ FDirName $(HAIKU_FFMPEG_DIR) common include ] ;
-	HAIKU_SPEEX_HEADERS = [ FDirName $(HAIKU_SPEEX_DIR) common include ] ;
-	HAIKU_LIBTHEORA_HEADERS = [ FDirName $(HAIKU_LIBTHEORA_DIR) common include ] ;
-	HAIKU_LIBVORBIS_HEADERS = [ FDirName $(HAIKU_LIBVORBIS_DIR) common include ] ;
-	HAIKU_LIBOGG_HEADERS = [ FDirName $(HAIKU_LIBOGG_DIR) common include ] ;
-	HAIKU_LIBVPX_HEADERS = [ FDirName $(HAIKU_LIBVPX_DIR) common include ] ;
-
-	EnableBuildFeatures ffmpeg ;
 } else {
-	Echo "FFMpeg support not available on $(TARGET_ARCH)" ;
+	Echo "FFMpeg support not available on $(TARGET_PACKAGING_ARCH)" ;
-}
-
-
-# MikMod
-local mikmodBaseURL = http://haiku-files.org/files/optional-packages/lib ;
-if $(TARGET_ARCH) = x86 {
-	if $(HAIKU_GCC_VERSION[1]) >= 4 {
-		HAIKU_MIKMOD_FILE = libmikmod-3.1.11-r1a4-x86-gcc4-2012-09-02.zip ;
-	} else {
-		HAIKU_MIKMOD_FILE = libmikmod-3.1.11-r1a4-x86-gcc2-2012-08-29.zip ;
-	}
-
-	local mikmodZipFile = [ DownloadFile $(HAIKU_MIKMOD_FILE)
-		: $(mikmodBaseURL)/$(HAIKU_MIKMOD_FILE) ] ;
-
-	HAIKU_MIKMOD_DIR = [ FDirName $(HAIKU_OPTIONAL_BUILD_PACKAGES_DIR)
-		$(HAIKU_MIKMOD_FILE:B) ] ;
-
-	HAIKU_MIKMOD_HEADERS_DEPENDENCY = [ ExtractArchive $(HAIKU_MIKMOD_DIR)
-		: common/include/ : $(mikmodZipFile) : extracted-mikmod ] ;
-
-	HAIKU_MIKMOD_LIBS = [ ExtractArchive $(HAIKU_MIKMOD_DIR)
-		:
-		common/lib/libmikmod.a
-		: $(mikmodZipFile)
-		: extracted-ffmpeg ] ;
-	Depends $(HAIKU_MIKMOD_LIBS) : $(HAIKU_MIKMOD_HEADERS_DEPENDENCY) ;
-
-	HAIKU_MIKMOD_HEADERS = [ FDirName $(HAIKU_MIKMOD_DIR) common include ] ;
-
-	EnableBuildFeatures mikmod ;
-} else {
-	Echo "MikMod support not available on $(TARGET_ARCH)" ;
 }
 
 
 # Freetype
-local freetypeBaseURL = $(baseURL)/lib ;
+if [ IsPackageAvailable freetype_devel ] {
-if $(TARGET_ARCH) = ppc || $(TARGET_ARCH) = x86 || $(TARGET_ARCH) = x86_64 || $(TARGET_ARCH) = arm {
+	ExtractBuildFeatureArchives freetype :
-	if $(TARGET_ARCH) = arm {
+		file: base freetype
-		HAIKU_FREETYPE_FILE = freetype-2.4.9-arm-2012-11-21.zip ;
+			runtime: lib
-	} else if $(TARGET_ARCH) = ppc {
+		file: devel freetype_devel
-		HAIKU_FREETYPE_FILE = freetype-2.4.9-ppc-gcc4-2012-06-26.zip ;
+			depends: base
-	} else if $(TARGET_ARCH) = x86_64 {
+			library: $(developLibDir)/libfreetype.so
-		HAIKU_FREETYPE_FILE = freetype-2.4.9-x86_64-2012-08-04.zip ;
+			headers: $(developHeadersDir) $(developHeadersDir)/freetype2
-	} else if $(HAIKU_GCC_VERSION[1]) >= 4 {
+		;
-		HAIKU_FREETYPE_FILE = freetype-2.4.9-r1a4-x86-gcc4-2012-09-02.zip ;
-	} else {
-		HAIKU_FREETYPE_FILE = freetype-2.4.9-r1a4-x86-gcc2-2012-08-28.zip ;
-	}
-
-	local freetypeZipFile = [ DownloadFile $(HAIKU_FREETYPE_FILE)
-		: $(freetypeBaseURL)/$(HAIKU_FREETYPE_FILE) ] ;
-
-	HAIKU_FREETYPE_DIR = [ FDirName $(HAIKU_OPTIONAL_BUILD_PACKAGES_DIR)
-		$(HAIKU_FREETYPE_FILE:B) ] ;
-
-	HAIKU_FREETYPE_HEADERS_DEPENDENCY = [ ExtractArchive $(HAIKU_FREETYPE_DIR)
-		: develop/headers/3rdparty/freetype2 : $(freetypeZipFile)
-		: extracted-freetype ] ;
-
-	HAIKU_FREETYPE_LIB = [ ExtractArchive $(HAIKU_FREETYPE_DIR)
-		:
-		common/lib/libfreetype.so
-		: $(freetypeZipFile)
-		: extracted-freetype ] ;
-	HAIKU_FREETYPE_CURRENT_LIB = [ ExtractArchive $(HAIKU_FREETYPE_DIR)
-		:
-		common/lib/libfreetype.so.6.8.1
-		: $(freetypeZipFile)
-		: extracted-freetype ] ;
-	Depends $(HAIKU_FREETYPE_LIB) $(HAIKU_FREETYPE_CURRENT_LIB) : $(HAIKU_FREETYPE_HEADERS_DEPENDENCY) ;
-
-	HAIKU_FREETYPE_CURRENT_LINK = libfreetype.so.6 ;
-
-	HAIKU_FREETYPE_HEADERS = [ FDirName $(HAIKU_FREETYPE_DIR) develop
-		headers 3rdparty ] [ FDirName $(HAIKU_FREETYPE_DIR) develop
-		headers 3rdparty freetype2 ] ;
 
 	EnableBuildFeatures freetype ;
 } else {
-	Echo "Freetype support not available on $(TARGET_ARCH)" ;
+	Echo "Freetype support not available on $(TARGET_PACKAGING_ARCH)" ;
 }
 
 
 # TagLib
 
+# TODO: Update to packages!
+if ! 1 {
+
 # Automatically install the TagLib feature, when the optional TagLib optional
 # package is enabled.
-if [ IsOptionalHaikuImagePackageAdded TagLib ] {
+if [ IsHaikuImagePackageAdded taglib ] {
 	HAIKU_BUILD_FEATURE_TAGLIB = 1 ;
 }
 
@@ -505,7 +338,7 @@ HAIKU_TAGLIB_URL = $(baseURL)/$(HAIKU_TAGLIB_PACKAGE) ;
 
 if $(HAIKU_BUILD_FEATURE_TAGLIB) {
 	if $(TARGET_ARCH) != x86 {
-		Echo "TagLib build feature not available for $(TARGET_ARCH)" ;
+		Echo "TagLib build feature not available for $(TARGET_PACKAGING_ARCH)" ;
 	} else {
 		# Download the zip archive.
 		local zipFile = [ DownloadFile $(HAIKU_TAGLIB_PACKAGE)
@@ -536,190 +369,107 @@ if $(HAIKU_BUILD_FEATURE_TAGLIB) {
 	}
 }
 
+} # ! 1
+
 
 # WebKit
-# Automatically install the WebKit feature, when the optional WebPositive
+if [ IsPackageAvailable haikuwebkit_devel ] {
-# optional package is enabled.
+	ExtractBuildFeatureArchives webkit :
-if [ IsOptionalHaikuImagePackageAdded WebPositive ] {
+		file: base haikuwebkit
-	HAIKU_BUILD_FEATURE_WEBKIT = 1 ;
+			runtime: lib
+		file: devel haikuwebkit_devel
+			depends: base
+			libraries:
+				$(developLibDir)/libwtf.so
+				$(developLibDir)/libjavascriptcore.so
+				$(developLibDir)/libwebcore.so
+				$(developLibDir)/libwebkit.so
+			headers: $(developHeadersDir)
+		;
+
+	EnableBuildFeatures webkit ;
+} else {
+	Echo "WebKit build feature not available for $(TARGET_PACKAGING_ARCH)" ;
 }
 
-if $(TARGET_ARCH) = x86 {
-	HAIKU_WEBKIT_FILE = haikuwebkit-1.1.3-x86-gcc4-2012-08-31a.zip ;
-} else if $(TARGET_ARCH) = x86_64 {
-	HAIKU_WEBKIT_FILE = haikuwebkit-1.1.3-x86_64-gcc4-2012-12-22.zip ;
-}
-if $(HAIKU_BUILD_FEATURE_WEBKIT) {
-	if $(TARGET_ARCH) != x86 && $(TARGET_ARCH) != x86_64 {
-		Echo "WebKit support not available on $(TARGET_ARCH)" ;
-	} else if $(HAIKU_GCC_VERSION[1]) < 4 {
-		if ! $(isHybridBuild) {
-			Echo "WebKit support not available on gcc $(HAIKU_GCC_VERSION[1])" ;
-		} else {
-			Echo "WebKit to be utilized by gcc4 inside $(HAIKU_ALTERNATIVE_GCC_OUTPUT_DIR)" ;
-		}
-	} else {
-		local zipFile = [ DownloadFile $(HAIKU_WEBKIT_FILE)
-			: $(baseURL)/$(HAIKU_WEBKIT_FILE) ] ;
-
-		HAIKU_WEBKIT_DIR = [ FDirName $(HAIKU_OPTIONAL_BUILD_PACKAGES_DIR)
-			$(HAIKU_WEBKIT_FILE:B) ] ;
-
-		HAIKU_WEBKIT_HEADERS_DEPENDENCY = [ ExtractArchive $(HAIKU_WEBKIT_DIR)
-			: include/ : $(zipFile) : extracted-webkit ] ;
-
-		HAIKU_WEBKIT_LIBS = [ ExtractArchive $(HAIKU_WEBKIT_DIR)
-			:
-			lib/libwtf.so
-			lib/libjavascriptcore.so
-			lib/libwebcore.so
-			lib/libwebkit.so
-			: $(zipFile)
-			: extracted-webkit
-		] ;
-
-		HAIKU_WEBKIT_HEADERS = [ FDirName $(HAIKU_WEBKIT_DIR) include ] ;
-
-		EnableBuildFeatures webkit ;
-	}
-}
 
 # libpng
-local libpngBaseURL = $(baseURL)/lib ;
+if [ IsPackageAvailable libpng_devel ] {
-if $(TARGET_ARCH) = ppc || $(TARGET_ARCH) = x86 || $(TARGET_ARCH) = x86_64 || $(TARGET_ARCH) = arm {
+	ExtractBuildFeatureArchives libpng :
-	if $(TARGET_ARCH) = arm {
+		file: base libpng
-		HAIKU_LIBPNG_FILE = libpng-1.5.12-arm-2012-11-21.zip ;
+			runtime: lib
-	} else if $(TARGET_ARCH) = ppc {
+		file: devel libpng_devel
-		HAIKU_LIBPNG_FILE = libpng-1.5.12-ppc-gcc4-2012-08-27.zip ;
+			depends: base
-	} else if $(TARGET_ARCH) = x86_64 {
+			library: $(developLibDir)/libpng.so
-		HAIKU_LIBPNG_FILE = libpng-1.5.12-x86_64-2012-11-18.zip ;
+			headers: $(developHeadersDir)
-	} else if $(HAIKU_GCC_VERSION[1]) >= 4 {
+		;
-		HAIKU_LIBPNG_FILE = libpng-1.5.12-x86-gcc4-2012-08-23.zip ;
-	} else {
-		HAIKU_LIBPNG_FILE = libpng-1.5.12-x86-gcc2-2012-08-23.zip ;
-	}
-
-	local libpngZipFile = [ DownloadFile $(HAIKU_LIBPNG_FILE)
-		: $(libpngBaseURL)/$(HAIKU_LIBPNG_FILE) ] ;
-
-	HAIKU_LIBPNG_DIR = [ FDirName $(HAIKU_OPTIONAL_BUILD_PACKAGES_DIR)
-		$(HAIKU_LIBPNG_FILE:B) ] ;
-
-	HAIKU_LIBPNG_HEADERS_DEPENDENCY = [ ExtractArchive $(HAIKU_LIBPNG_DIR)
-		: common/include : $(libpngZipFile)
-		: extracted-libpng ] ;
-
-	HAIKU_LIBPNG_LIB = [ ExtractArchive $(HAIKU_LIBPNG_DIR)
-		:
-		common/lib/libpng.so
-		: $(libpngZipFile)
-		: extracted-libpng ] ;
-	HAIKU_LIBPNG_CURRENT_LIB = [ ExtractArchive $(HAIKU_LIBPNG_DIR)
-		:
-		common/lib/libpng15.so.15.12.0
-		: $(libpngZipFile)
-		: extracted-libpng ] ;
-	Depends $(HAIKU_LIBPNG_LIB) $(HAIKU_LIBPNG_CURRENT_LIB) : $(HAIKU_LIBPNG_HEADERS_DEPENDENCY) ;
-
-	HAIKU_LIBPNG_CURRENT_LINK = libpng15.so.15 ;
-
-	HAIKU_LIBPNG_HEADERS = [ FDirName $(HAIKU_LIBPNG_DIR) common include ] ;
 
 	EnableBuildFeatures libpng ;
 } else {
-	Echo "libpng support not available on $(TARGET_ARCH)" ;
+	Echo "libpng support not available on $(TARGET_PACKAGING_ARCH)" ;
 }
 
+
 # jpeg
-local jpegBaseURL = $(baseURL)/lib ;
+if [ IsPackageAvailable jpeg_devel ] {
-if $(TARGET_ARCH) in arm ppc x86 x86_64 {
+	ExtractBuildFeatureArchives jpeg :
-	if $(TARGET_ARCH) = arm {
+		file: base jpeg
-		HAIKU_JPEG_FILE = jpeg-8d-arm-2012-11-21.zip ;
+			runtime: lib
-	} else if $(TARGET_ARCH) = ppc {
+		file: devel jpeg_devel
-		HAIKU_JPEG_FILE = jpeg-8d-ppc-gcc4-2012-08-27.zip ;
+			depends: base
-	} else if $(TARGET_ARCH) = x86_64 {
+			library: $(developLibDir)/libjpeg.so
-		HAIKU_JPEG_FILE = jpeg-8d-x86_64-2012-11-18.zip ;
+			headers: $(developHeadersDir)
-	} else if $(HAIKU_GCC_VERSION[1]) >= 4 {
+		;
-		HAIKU_JPEG_FILE = jpeg-8d-x86-gcc4-2012-08-23.zip ;
-	} else {
-		HAIKU_JPEG_FILE = jpeg-8d-x86-gcc2-2012-08-23.zip ;
-	}
 
-	local jpegZipFile = [ DownloadFile $(HAIKU_JPEG_FILE)
+	EnableBuildFeatures jpeg ;
-		: $(jpegBaseURL)/$(HAIKU_JPEG_FILE) ] ;
-
-	HAIKU_JPEG_DIR = [ FDirName $(HAIKU_OPTIONAL_BUILD_PACKAGES_DIR)
-		$(HAIKU_JPEG_FILE:B) ] ;
-
-	HAIKU_JPEG_HEADERS_DEPENDENCY = [ ExtractArchive $(HAIKU_JPEG_DIR)
-		: common/include : $(jpegZipFile)
-		: extracted-jpeg ] ;
-
-	HAIKU_JPEG_LIB = [ ExtractArchive $(HAIKU_JPEG_DIR)
-		:
-		common/lib/libjpeg.so
-		: $(jpegZipFile)
-		: extracted-jpeg ] ;
-	HAIKU_JPEG_CURRENT_LIB = [ ExtractArchive $(HAIKU_JPEG_DIR)
-		:
-		common/lib/libjpeg.so.8.4.0
-		: $(jpegZipFile)
-		: extracted-jpeg ] ;
-	Depends $(HAIKU_JPEG_LIB) $(HAIKU_JPEG_CURRENT_LIB) : $(HAIKU_JPEG_HEADERS_DEPENDENCY) ;
-
-	HAIKU_JPEG_CURRENT_LINK = libjpeg.so.8 ;
-
-	HAIKU_JPEG_HEADERS = [ FDirName $(HAIKU_JPEG_DIR) common include ] ;
-
-	EnableBuildFeatures libjpeg ;
 } else {
-	Echo "jpeg support not available on $(TARGET_ARCH)" ;
+	Echo "jpeg support not available on $(TARGET_PACKAGING_ARCH)" ;
 }
 
+
 # zlib
-local zlibBaseURL = $(baseURL)/lib ;
+if [ IsPackageAvailable zlib_devel ] {
-if $(TARGET_ARCH) = ppc || $(TARGET_ARCH) = x86 || $(TARGET_ARCH) = x86_64 || $(TARGET_ARCH) = arm {
+	ExtractBuildFeatureArchives zlib :
-	if $(TARGET_ARCH) = arm {
+		file: base zlib
-		HAIKU_ZLIB_FILE = zlib-1.2.7-arm-2012-11-21.zip ;
+			runtime: lib
-	} else if $(TARGET_ARCH) = ppc {
+		file: devel zlib_devel
-		HAIKU_ZLIB_FILE = zlib-1.2.7-ppc-gcc4-2012-10-30.zip ;
+			depends: base
-	} else if $(TARGET_ARCH) = x86_64 {
+			library: $(developLibDir)/libz.so
-		HAIKU_ZLIB_FILE = zlib-1.2.7-x86_64-2012-11-18.zip ;
+			headers: $(developHeadersDir)
-	} else if $(HAIKU_GCC_VERSION[1]) >= 4 {
+		# sources are required for the primary architecture only
-		HAIKU_ZLIB_FILE = zlib-1.2.7-x86-gcc4-2012-10-30.zip ;
+		primary @{
-	} else {
+			file: source zlib_source
-		HAIKU_ZLIB_FILE = zlib-1.2.7-x86-gcc2-2012-10-30.zip ;
+				sources: develop/sources/%portRevisionedName%/source
-	}
+		}@
-
+		;
-	local zlibZipFile = [ DownloadFile $(HAIKU_ZLIB_FILE)
-		: $(zlibBaseURL)/$(HAIKU_ZLIB_FILE) ] ;
-
-	HAIKU_ZLIB_DIR = [ FDirName $(HAIKU_OPTIONAL_BUILD_PACKAGES_DIR)
-		$(HAIKU_ZLIB_FILE:B) ] ;
-
-	HAIKU_ZLIB_HEADERS_DEPENDENCY = [ ExtractArchive $(HAIKU_ZLIB_DIR)
-		: common/include : $(zlibZipFile)
-		: extracted-zlib ] ;
-
-	HAIKU_ZLIB_LIB = [ ExtractArchive $(HAIKU_ZLIB_DIR)
-		:
-		common/lib/libz.so
-		: $(zlibZipFile)
-		: extracted-zlib ] ;
-	HAIKU_ZLIB_CURRENT_LIB = [ ExtractArchive $(HAIKU_ZLIB_DIR)
-		:
-		common/lib/libz.so.1.2.7
-		: $(zlibZipFile)
-		: extracted-zlib ] ;
-	Depends $(HAIKU_ZLIB_LIB) $(HAIKU_ZLIB_CURRENT_LIB) : $(HAIKU_ZLIB_HEADERS_DEPENDENCY) ;
-
-	HAIKU_ZLIB_CURRENT_LINK = libz.so.1 ;
-
-	HAIKU_ZLIB_HEADERS = [ FDirName $(HAIKU_ZLIB_DIR) common include ] ;
 
 	EnableBuildFeatures zlib ;
 } else {
-	Echo "zlib support not available on $(TARGET_ARCH)" ;
+	Echo "zlib support not available on $(TARGET_PACKAGING_ARCH)" ;
+}
+
+
+# libsolv
+if [ IsPackageAvailable libsolv_devel ] {
+	ExtractBuildFeatureArchives libsolv :
+		file: base libsolv
+			runtime: lib
+		file: devel libsolv_devel
+			depends: base
+			libraries:
+				$(developLibDir)/libsolv.so
+				$(developLibDir)/libsolvext.so
+			headers: $(developHeadersDir)
+		# sources are required for the primary architecture only
+		primary @{
+			file: source libsolv_source
+				sources: develop/sources/%portRevisionedName%/source
+		}@
+		;
+
+	EnableBuildFeatures libsolv ;
+} else {
+	Echo "libsolv package not available for $(TARGET_PACKAGING_ARCH)" ;
 }
 
 

build/jam/CommandLineArguments

@@ -66,6 +66,16 @@ rule ProcessCommandLineArguments
 				}
 			}
 
+			# Copy the given set of local package files to the remote repository
+			# and create a new version of that remote repository.
+			case build-remote-repository : {
+				BuildRemoteHaikuPortsRepository $(JAM_TARGETS[1])
+					: $(JAM_TARGETS[2-]) ;
+				JAM_TARGETS = $(JAM_TARGETS[1]) ;
+				NotFile $(JAM_TARGETS) ;
+				Always $(JAM_TARGETS) ;
+			}
+
 			# A target starting with "@" is a build profile.
 			case @* : {
 				HAIKU_BUILD_PROFILE = [ Match "@(.*)" : $(JAM_TARGETS[1]) ] ;
@@ -81,7 +91,9 @@ rule ProcessCommandLineArguments
 				if $(JAM_TARGETS[1]) in update-image update-vmware-image
 						update-install {
 					SetUpdateHaikuImageOnly 1 ;
+					HAIKU_PACKAGES_UPDATE_ONLY = 1 ;
 					HAIKU_INCLUDE_IN_IMAGE on $(JAM_TARGETS[2-]) = 1 ;
+					HAIKU_INCLUDE_IN_PACKAGES on $(JAM_TARGETS[2-]) = 1 ;
 
 					if $(JAM_TARGETS[1]) = update-image {
 						JAM_TARGETS = haiku-image ;

build/jam/DefaultBuildProfiles

@@ -0,0 +1,201 @@
+# set HAIKU_BOOTSTRAP_BUILD early, if building a bootstrap Haiku image
+switch $(HAIKU_BUILD_PROFILE) {
+	case "bootstrap-*" :
+		HAIKU_BOOTSTRAP_BUILD = 1 ;
+}
+
+
+rule DefineDefaultBuildProfiles
+{
+	# alpha release profiles
+	DefineBuildProfile alpha-raw : image : "haiku-alpha.image" ;
+	DefineBuildProfile alpha-vmware : vmware-image : "haiku-alpha.vmdk" ;
+	DefineBuildProfile alpha-cd : cd-image : "haiku-alpha.iso" ;
+	DefineBuildProfile alpha-anyboot : anyboot-image
+		: "haiku-alpha-anyboot.image" ;
+
+	# nightly profiles
+	DefineBuildProfile nightly-raw : image : "haiku-nightly.image" ;
+	DefineBuildProfile nightly-vmware : vmware-image : "haiku-nightly.vmdk" ;
+	DefineBuildProfile nightly-cd : cd-image : "haiku-nightly.iso" ;
+	DefineBuildProfile nightly-anyboot : anyboot-image
+		: "haiku-nightly-anyboot.image" ;
+
+	# bootstrap profiles
+	DefineBuildProfile bootstrap-raw : image : "haiku-bootstrap.image" ;
+	DefineBuildProfile bootstrap-vmware : vmware-image
+		: "haiku-bootstrap.vmdk" ;
+
+	switch $(HAIKU_BUILD_PROFILE) {
+		case "alpha-*" : {
+			Echo Building Haiku R1/alpha ;
+			HAIKU_ROOT_USER_NAME = user ;
+			HAIKU_ROOT_USER_REAL_NAME = "Yourself" ;
+			AddGroupToHaikuImage party : 101 : user sshd ;
+			HAIKU_IMAGE_HOST_NAME = shredder ;
+			HAIKU_IMAGE_SIZE = 800 ;
+
+			AddHaikuImagePackages
+				wpa_supplicant
+				:
+				system
+				;
+
+			AddHaikuImagePackages
+				bepdf
+				cvs
+				keymapswitcher
+				man
+				mercurial
+				nano
+				openssh
+				p7zip
+				pe
+				python
+				subversion
+				timgmsoundfont
+				vision
+				wonderbrush
+				wqy_microhei
+				xz_utils@!gcc2
+				;
+
+			# xz_utils can't be built with gcc2, so a mere gcc2 system doesn't
+			# have it. However, xz_utils does exist for the secondary (gcc4)
+			# architecture of a gcc2 hybrid.
+			if $(HAIKU_PACKAGING_ARCHS) != x86_gcc2 {
+				AddHaikuImagePackages
+					xz_utils_x86@gcc2
+					;
+			}
+
+			local architectureObject ;
+			for architectureObject in [ MultiArchSubDirSetup ] {
+				on $(architectureObject) {
+					AddHaikuImagePackages openssl : system ;
+				}
+			}
+
+			AddOptionalHaikuImagePackages BeBook Development Git WebPositive
+				Welcome ;
+		}
+
+		case "beta-*" : {
+			Echo You wish. ;
+		}
+
+		case "nightly-*" : {
+			Echo Building Haiku Nightly ;
+			HAIKU_ROOT_USER_NAME = user ;
+			HAIKU_ROOT_USER_REAL_NAME = "Yourself" ;
+			AddGroupToHaikuImage party : 101 : user sshd ;
+			HAIKU_IMAGE_HOST_NAME = shredder ;
+			HAIKU_IMAGE_SIZE = 600 ;
+
+			AddHaikuImagePackages
+				openssl
+				wpa_supplicant
+				:
+				system
+				;
+
+			AddHaikuImagePackages
+				man
+				nano
+				openssh
+				p7zip
+				pe
+				vision
+				xz_utils
+				;
+
+			AddOptionalHaikuImagePackages Development Git WebPositive ;
+		}
+
+		case "bootstrap-*" : {
+			Echo Building Haiku Bootstrap ;
+			HAIKU_IMAGE_HOST_NAME = shredder ;
+			HAIKU_IMAGE_SIZE = 20000 ;
+
+			AddHaikuImagePackages
+				freetype
+				freetype_devel
+				grep
+				icu
+				libsolv
+				ncurses
+				ncurses_devel
+				sed
+				zlib
+				zlib_devel
+				:
+				system
+				;
+
+			AddHaikuImagePackages
+				autoconf
+				automake
+				binutils
+				bison
+				flex
+				gcc
+				haikuporter
+#				jam
+				libtool
+				libtool_libltdl
+				m4
+				make
+#				makeinfo
+#				mkdepend
+#				perl
+				python
+#				texinfo
+				;
+
+			# secondary architecture packages
+			local architectureObject ;
+			for architectureObject
+					in [ MultiArchSubDirSetup $(TARGET_PACKAGING_ARCHS[2-]) ] {
+				on $(architectureObject) {
+					AddHaikuImagePackages
+						freetype
+						freetype_devel
+						icu
+						libsolv
+						ncurses
+						ncurses_devel
+						zlib
+						zlib_devel
+						:
+						system
+						;
+
+					AddHaikuImagePackages
+						binutils
+						gcc
+						;
+				}
+			}
+
+			AddOptionalHaikuImagePackages DevelopmentMin ;
+		}
+	}
+
+
+	# Uncomment in official release branch.
+	#HAIKU_DEFINES += HAIKU_OFFICIAL_RELEASE ;
+	#TARGET_DEFINES += HAIKU_OFFICIAL_RELEASE ;
+
+
+	# If a build profile was specified on the command line, now is the time to
+	# check whether it is unknown or one of the default profiles.
+	if $(HAIKU_BUILD_PROFILE) && ! $(HAIKU_BUILD_PROFILE_DEFINED) {
+		# define the obvious default profiles
+		if $(HAIKU_BUILD_PROFILE) in anyboot-image cd-image image install
+				vmware-image {
+			DefineBuildProfile $(HAIKU_BUILD_PROFILE) : $(HAIKU_BUILD_PROFILE) ;
+		} else {
+			Exit "Build profile" $(HAIKU_BUILD_PROFILE) "not defined." ;
+		}
+	}
+}

build/jam/FileRules

@@ -1,3 +1,20 @@
+rule Copy
+{
+	if $(2) {
+		SEARCH on $(2) += $(SEARCH_SOURCE) ;
+		Depends $(1) : <build>copyattr $(2) ;
+		Copy1 $(1) : <build>copyattr $(2) ;
+	}
+}
+
+
+actions Copy1
+{
+	$(HOST_ADD_BUILD_COMPATIBILITY_LIB_DIR)
+	"$(2[1])" -d "$(2[2-])" "$(1)"
+}
+
+
 rule SymLink
 {
 	# SymLink <target> : <source> : <makeDefaultDependencies> ;
@@ -186,7 +203,8 @@ rule UnarchiveObjects
 
 actions UnarchiveObjects
 {
-	( cd $(1[1]:D) && $(TARGET_AR) $(TARGET_UNARFLAGS) "$(2)" $(1:BS) )
+	( cd $(1[1]:D) && $(TARGET_AR_$(TARGET_PACKAGING_ARCH)) \
+		$(TARGET_UNARFLAGS_$(TARGET_PACKAGING_ARCH)) "$(2)" $(1:BS) )
 }
 
 
@@ -220,7 +238,7 @@ rule ExtractArchive directory : entries : archiveFile : grist
 		targets += $(target) ;
 	}
 
-	LOCATE on $(targets) = $(directory) ;
+	LOCATE on $(targets) = $(directory:G=) ;
 	Depends $(targets) : $(directory) $(archiveFile) ;
 	NoUpdate $(targets) ;
 
@@ -235,40 +253,53 @@ rule ExtractArchive directory : entries : archiveFile : grist
 		Depends $(directory) : $(archiveFile) ;
 		switch $(archiveFile:S)
 		{
-			case .zip 	: ExtractZipArchive1 $(targets) : $(directory)
+			case .zip :
-							$(archiveFile) ;
+				ExtractZipArchive1 $(directory) : $(archiveFile) ;
-			case .tgz 	: ExtractTarArchive1 $(targets) : $(directory)
+
-							$(archiveFile) ;
+			case .tgz :
-			case ""		: Exit "ExtractArchive: No archive passed" ;
+				ExtractTarArchive1 $(directory) : $(archiveFile) ;
-			case * 		: Exit "ExtractArchive: Unhandled archive extension:
+
-							$(archiveFile:S)" ;
+			case .hpkg :
+				Depends $(directory) : <build>package ;
+				ExtractHPKGArchive1 $(directory)
+					: <build>package $(archiveFile) ;
+
+			case "" :
+				Exit "ExtractArchive: No archive passed" ;
+
+			case * :
+				Exit "ExtractArchive: Unhandled archive extension:"
+					"$(archiveFile:S)" ;
 		}
 		INITIALIZED on $(directory) = 1 ;
 	}
 
-	# Use a dummy rule so that it looks to jam like the targets are actually
-	# built from the directory target.
-	ExtractArchiveDummy $(targets) : $(directory) ;
-
 	return $(targets) ;
 }
 
+
 actions ExtractZipArchive1
 {
-	mkdir -p $(2[1])
+	mkdir -p $(1)
-	unzip -q -u -o -d $(2[1]) $(2[2])
+	unzip -q -u -o -d $(1) $(2)
 }
 
+
 actions ExtractTarArchive1
 {
-	mkdir -p $(2[1])
+	mkdir -p $(1)
-	tar -C $(2[1]) -xf $(2[2])
+	tar -C $(1) -xf $(2)
 }
 
-actions ExtractArchiveDummy
+
+actions ExtractHPKGArchive1
 {
+	mkdir -p "$(1)"
+	$(HOST_ADD_BUILD_COMPATIBILITY_LIB_DIR)
+	$(2[1]) extract -C "$(1)" "$(2[2])"
 }
 
+
 rule ObjectReference
 {
 	# ObjectReference <reference object> : <source object>
@@ -297,52 +328,63 @@ rule ObjectReferences
 	}
 }
 
+
 rule CopySetHaikuRevision target : source
 {
 	# CopySetHaikuRevision <target> : <source>
 	#
-	# Copy <source> to <target>, writing the SVN revision of the working root
+	# Copy <source> to <target>, writing the Git revision of the working
 	# directory into the haiku revision section of <target>.
 	#
 	# <target> - Output file target. Gristed and located target.
 	# <source> - ELF object to be copied. Gristed and located target.
 
-	# If existent, make the target depend on the .svn/entries file in the
+	# If existing, make the target depend on the .git/index file in the
 	# root directory, so it gets updated when the revision changes due to
-	# "svn up".
+	# commits or merges.
-	if [ Glob [ FDirName $(HAIKU_TOP) .svn ] : entries ] {
+	local gitIndex = <haiku-rootdir-git>index ;
-		local svnEntries = <haiku-rootdir-svn>entries ;
+	local revisionFile = <haiku-rootdir-git>haiku-revision ;
-		SEARCH on $(svnEntries) = [ FDirName $(HAIKU_TOP) .svn ] ;
+	if ! [ on $(gitIndex) return $(HAIKU_GIT_REVISION_DETERMINED) ] {
-		Depends $(target) : $(svnEntries) ;
+		if [ Glob [ FDirName $(HAIKU_TOP) .git ] : index ] {
-	} else if [ Glob [ FDirName $(HAIKU_TOP) .git ] : index ] {
+			HAIKU_GIT_REVISION_DETERMINED on $(gitIndex) = 1 ;
-		local gitIndex = <haiku-rootdir-git>index ;
+			SEARCH on $(gitIndex) = [ FDirName $(HAIKU_TOP) .git ] ;
-		SEARCH on $(gitIndex) = [ FDirName $(HAIKU_TOP) .git ] ;
+			MakeLocate $(revisionFile) : $(HAIKU_BUILD_OUTPUT_DIR) ;
-		Depends $(target) : $(gitIndex) ;
+			Depends $(revisionFile) : $(gitIndex) ;
-	} else if [ Glob [ FDirName $(HAIKU_TOP) .hg ] : store ] {
+			DetermineHaikuRevision $(revisionFile) : $(gitIndex) ;
-		local hgStore = <haiku-rootdir-hg>store ;
+		} else {
-		SEARCH on $(hgStore) = [ FDirName $(HAIKU_TOP) .hg ] ;
+			revisionFile = ;
-		Depends $(target) : $(hgStore) ;
+		}
 	}
 
-	HAIKU_INCLUDE_IN_IMAGE on $(target)
+	PropagateContainerUpdateTargetFlags $(target) : $(source) ;
-		= [ on $(source) return $(HAIKU_INCLUDE_IN_IMAGE) ] ;
 
-	Depends $(target) : <build>copyattr <build>set_haiku_revision $(source) ;
+	Depends $(target)
+		: <build>copyattr <build>set_haiku_revision $(source) $(revisionFile) ;
 	CopySetHaikuRevision1 $(target)
-		: <build>copyattr <build>set_haiku_revision $(source) ;
+		: <build>copyattr <build>set_haiku_revision $(source) $(revisionFile) ;
 }
 
+
 actions CopySetHaikuRevision1
 {
 	$(HOST_ADD_BUILD_COMPATIBILITY_LIB_DIR)
 
-	. $(HAIKU_TOP)/build/scripts/determine_haiku_revision
+	$(2[1]) --data $(2[3]) $(1) || exit 1
-	determineHaikuRevision $(HAIKU_TOP) $(HAIKU_BUILD_OUTPUT_DIR)
 
-	$(2[1]) --data $(2[3]) $(1) &&
+	revision=0
-	$(2[2]) $(1) ${revision}
+	if [ -n "$(2[4]:E=)" ]; then
+		revision="`cat $(2[4]:E=)`"
+	fi
+	$(2[2]) $(1) "$revision"
 }
 
+
+actions DetermineHaikuRevision
+{
+	$(HAIKU_TOP)/build/scripts/determine_haiku_revision $(HAIKU_TOP) $(1)
+}
+
+
 rule DataFileToSourceFile sourceFile : dataFile : dataVariable : sizeVariable
 {
 	sourceFile = [ FGristFiles $(sourceFile) ] ;
@@ -364,20 +406,36 @@ actions DataFileToSourceFile1
 	$(2[1]) $(DATA_VARIABLE) $(SIZE_VARIABLE) $(2[2]) $(1)
 }
 
-rule DownloadLocatedFile target : url
+rule DownloadLocatedFile target : url : source
 {
+	# DownloadLocatedFile <target> : <url> [ : <source> ] ;
+	#
+	# <source> is an optional target that <target> will be made dependent on.
+	# Its resolved path can be used in <url> via '$source'.
+
 	URL on $(target) = $(url) ;
 
-	DownloadLocatedFile1 $(target) ;
+	if $(source) {
+		Depends $(target) : $(source) ;
+	}
+
+	DownloadLocatedFile1 $(target) : $(source) ;
 }
 
 actions DownloadLocatedFile1
 {
-	wget -O "$(1)" $(URL)
+	source="$(2)"
+	wget -O "$(1)" $(URL) || exit 1
+	touch "$(1)"
 }
 
-rule DownloadFile file : url
+rule DownloadFile file : url : source
 {
+	# DownloadFile <file> : <url> [ : <source> ] ;
+	#
+	# <source> is an optional target that the target will be made dependent on.
+	# Its resolved path can be used in <url> via '$source'.
+
 	file = $(file:G=download) ;
 
 	# Request the download only once.
@@ -388,8 +446,15 @@ rule DownloadFile file : url
 	HAIKU_FILE_DOWNLOAD on $(file) = 1 ;
 
 	MakeLocate $(file) : $(HAIKU_DOWNLOAD_DIR) ;
-	DownloadLocatedFile $(file) : $(url) ;
+	DownloadLocatedFile $(file) : $(url) : $(source) ;
 
 	return $(file) ;
 }
 
+
+actions ChecksumFileSHA256
+{
+	$(HOST_SHA256) $(2) | sed -r 's,([^[:space:]]*).*,\1,' > $(1)
+		# The sed part is only necessary for sha256sum, but it doesn't harm for
+		# sha256 either.
+}

build/jam/HaikuPackages

@@ -0,0 +1,60 @@
+# The packages we build. Each is defined in its own file in the packages/
+# subdirectory.
+local packages =
+	HaikuDevel
+	HaikuLoader
+	HaikuUserguide
+	HaikuWelcome
+	MakefileEngine
+	;
+
+if $(HAIKU_BOOTSTRAP_BUILD) {
+	packages += HaikuBootstrap ;
+} else {
+	packages += Haiku ;
+}
+
+local archDependentPackages =
+	HaikuCrossDevel
+	WebPositive
+	;
+
+local secondaryArchPackages =
+	HaikuDevelSecondary
+	;
+if $(HAIKU_BOOTSTRAP_BUILD) {
+	secondaryArchPackages += HaikuSecondaryBootstrap ;
+} else {
+	secondaryArchPackages += HaikuSecondary ;
+}
+
+
+packages = $(packages:G=package-rules) ;
+archDependentPackages = $(archDependentPackages:G=package-rules) ;
+secondaryArchPackages = $(secondaryArchPackages:G=package-rules) ;
+SEARCH on $(packages) $(archDependentPackages) $(secondaryArchPackages)
+	= [ FDirName $(HAIKU_BUILD_RULES_DIR) packages ] ;
+
+local package ;
+for package in $(packages) {
+	include $(package) ;
+}
+
+for package in $(archDependentPackages) {
+	local architectureObject ;
+	for architectureObject in [ MultiArchSubDirSetup ] {
+		on $(architectureObject) {
+			include $(package) ;
+		}
+	}
+}
+
+for package in $(secondaryArchPackages) {
+	local architectureObject ;
+	for architectureObject in
+			[ MultiArchSubDirSetup $(TARGET_PACKAGING_ARCHS[2-]) ] {
+		on $(architectureObject) {
+			include $(package) ;
+		}
+	}
+}

build/jam/HeadersRules

@@ -71,11 +71,13 @@ rule ObjectSysHdrs
 					[ FSysIncludes $(sysHeaders)
 						: $(HOST_SYSTEM_INCLUDES_OPTION) ] ;
 			} else {
+				local architecture = $(TARGET_PACKAGING_ARCH) ;
 				fileHeaders =
-					[ FIncludes $(HDRS) : $(TARGET_LOCAL_INCLUDES_OPTION) ]
+					[ FIncludes $(HDRS)
-					$(TARGET_INCLUDES_SEPARATOR)
+						: $(TARGET_LOCAL_INCLUDES_OPTION_$(architecture)) ]
+					$(TARGET_INCLUDES_SEPARATOR_$(architecture))
 					[ FSysIncludes $(sysHeaders)
-						: $(TARGET_SYSTEM_INCLUDES_OPTION) ] ;
+						: $(TARGET_SYSTEM_INCLUDES_OPTION_$(architecture)) ] ;
 			}
 
 			ASHDRS on $(file) = $(fileHeaders) ;
@@ -408,7 +410,22 @@ rule UsePrivateKernelHeaders
 
 rule UsePrivateSystemHeaders
 {
-	UseHeaders $(TARGET_PRIVATE_SYSTEM_HEADERS) : true ;
+	UseHeaders $(TARGET_PRIVATE_SYSTEM_HEADERS_$(TARGET_PACKAGING_ARCH))
+		: true ;
+}
+
+
+rule UseBuildFeatureHeaders feature : attribute 
+{
+	# UseBuildFeatureHeaders <feature> : [ <attribute> ] ;
+	# A shorthand for
+	# UseHeaders [ BuildFeatureAttribute <feature> : <attribute> ] : true ;
+	# Moreover the default value for <attribute> is "headers", which usually
+	# allows the rule to be called with the feature name as the only parameter.
+
+	local headers = [ BuildFeatureAttribute $(feature) : $(attribute:E=headers)
+		: path ] ;
+	UseHeaders $(headers) : true ;
 }
 
 
@@ -426,7 +443,7 @@ rule FStandardOSHeaders
 }
 
 
-rule FStandardHeaders
+rule FStandardHeaders architecture
 {
 	local osIncludes = add-ons add-ons/file_system add-ons/graphics
 					   add-ons/input_server add-ons/registrar
@@ -439,14 +456,14 @@ rule FStandardHeaders
 
 	# The C++ headers. If specified, we use the compiler headers, otherwise
 	# the ones that come with our libstdc++.
-	if $(HAIKU_C++_HEADERS_DIR) {
+	if $(HAIKU_C++_HEADERS_DIR_$(architecture)) {
-		headers += $(HAIKU_C++_HEADERS_DIR) ;
+		headers += $(HAIKU_C++_HEADERS_DIR_$(architecture)) ;
 	} else {
 		headers += [ FDirName $(HAIKU_TOP) headers cpp ] ;
 	}
 
 	# GCC headers
-	headers += $(HAIKU_GCC_HEADERS_DIR) ;
+	headers += $(HAIKU_GCC_HEADERS_DIR_$(architecture)) ;
 
 	# Use headers directory, to allow to do things like include <posix/string.h>
 	headers += [ FDirName $(HAIKU_TOP) headers ] ;

build/jam/HelperRules

@@ -97,26 +97,28 @@ rule FSplitPath
 }
 
 
-rule FSetConditionsHold conditions : set
+rule FConditionsHold conditions : predicate
 {
-	# FSetConditionsHold <conditions> : <set> ;
+	# FConditionsHold <conditions> : <predicate> ;
-	# Checks whether the conditions <conditions> are satisfied by the list of
+	# Checks whether the conditions <conditions> are satisfied by the predicate
-	# elements <set> and returns a respective result (if so: "1", if not: empty
+	# rule <predicate> and returns a respective result (if so: "1", if not:
-	# list). The conditions are satisfied when <conditions> is not empty and
+	# empty list). The conditions are satisfied when <conditions> is not empty
+	# and
 	# * none of the negative conditions it contains hold and
-	# * if <conditions> contains any positive conditions, at least one one of
+	# * if <conditions> contains any positive conditions, at least one of those
-	#   those holds.
+	#   holds.
 	# A positive condition is an element not starting with a "!". It holds when
-	# the element is contained in <set>.
+	# the predicate rule <predicate> returns true for the element.
 	# A negative condition is an element that starts with a "!". It holds when
-	# the string resulting from removing the leading "!" is not contained in
+	# the predicate rule <predicate> returns true for the string resulting from
-	# <set>.
+	# removing the leading "!".
 	#
 	# <conditions> - The list of conditions.
-	# <set> - The elements against which the conditions are tested.
+	# <predicate> - The predicate rule invoked to test the elements.
 	#
 	# Examples:
-	# For set { a b c } the following conditions hold:
+	# For a predicate that holds for the elements of the set { a b c } the
+	# following conditions hold:
 	# { a }, { a d }, { !d }, { !d !e }, { a !d }, { b !e !f }
 	# The following conditions don't hold:
 	# { }, { d }, { d e }, { !a }, { !a b }, { !d e } { a b !c !d }
@@ -131,14 +133,14 @@ rule FSetConditionsHold conditions : set
 			{
 				hasNegative = 1 ;
 				condition = [ Match "!(.*)" : $(condition) ] ;
-				if $(condition) in $(set) {
+				if [ $(predicate) $(condition) ] {
 					return ;
 				}
 			}
 			case * :
 			{
 				hasPositive = 1 ;
-				if $(condition) in $(set) {
+				if [ $(predicate) $(condition) ] {
 					positiveMatch = 1 ;
 				}
 			}
@@ -205,6 +207,9 @@ rule SetPlatformCompatibilityFlagVariables
 			$(varPrefix)_PLATFORM_HAIKU_COMPATIBLE = true ;
 		}
 
+		case host :
+			# not compatible to anything
+
 		case * :
 		{
 			if ! ( $(platform) in $(otherPlatforms) ) {
@@ -267,19 +272,19 @@ rule FAnalyzeGCCVersion
 	return $(version) ;
 }
 
-rule SetIncludePropertiesVariables
+rule SetIncludePropertiesVariables prefix : suffix
 {
-	# SetIncludePropertiesVariables <varPrefix> ;
+	# SetIncludePropertiesVariables <prefix> : <suffix> ;
 	#
-	local prefix = $(1) ;
+	suffix = $(suffix:E=) ;
-	if $($(prefix)_GCC_VERSION[1]) < 4 {
+	if $($(prefix)_GCC_VERSION$(suffix)[1]) < 4 {
-		$(prefix)_INCLUDES_SEPARATOR = -I- ;
+		$(prefix)_INCLUDES_SEPARATOR$(suffix) = -I- ;
-		$(prefix)_LOCAL_INCLUDES_OPTION = -I ;
+		$(prefix)_LOCAL_INCLUDES_OPTION$(suffix) = -I ;
-		$(prefix)_SYSTEM_INCLUDES_OPTION = -I ;
+		$(prefix)_SYSTEM_INCLUDES_OPTION$(suffix) = -I ;
 	} else {
-		$(prefix)_INCLUDES_SEPARATOR = ;
+		$(prefix)_INCLUDES_SEPARATOR$(suffix) = ;
-		$(prefix)_LOCAL_INCLUDES_OPTION = "-iquote " ;
+		$(prefix)_LOCAL_INCLUDES_OPTION$(suffix) = "-iquote " ;
-		$(prefix)_SYSTEM_INCLUDES_OPTION = "-I " ;
+		$(prefix)_SYSTEM_INCLUDES_OPTION$(suffix) = "-I " ;
 	}
 }
 

build/jam/ImageRules

@@ -70,36 +70,55 @@ actions together AddVariableToScript1
 	$(VARIABLE_DEFS)$(1);
 }
 
-rule AddTargetVariableToScript
+
+rule AddTargetVariableToScript script : targets : variable
 {
-	# AddTargetVariableToScript <script> : <target> [ : <variable> ] ;
+	# AddTargetVariableToScript <script> : <targets> [ : <variable> ] ;
 	#
-	local script = $(1) ;
+	# If <targets> contains multiple targets, their paths must not contain
-	local target = $(2) ;
+	# whitespaces or other characters that need to be escaped in the shell.
-	local variable = $(3:E=$(target:BS)) ;
+	#
+	variable ?= $(3:E=$(targets[1]:BS)) ;
 
-	InitScript $(script) ;
+	local initScript = [ InitScript $(script) ] ;
 
-	# That's not completely save, if one has more than on target with the
+	serialization = [ on $(script) return $(HAIKU_SERIALIZATION) ] ;
-	# same base name. A unique pseudo target would have to be introduced
-	# to do it more correctly.
-	VARIABLE_NAME($(target:BS)) on $(script) = $(variable) ;
 
-	Depends $(script) : $(target) ;
+	local variableTarget = [ NewUniqueTarget ] ;
-	AddTargetVariableToScript1 $(script) : $(target) ;
+	NotFile $(variableTarget) ;
+	Depends $(variableTarget) : $(initScript) $(targets) $(serialization) ;
+	Depends $(script) : $(variableTarget) ;
+
+	HAIKU_SERIALIZATION on $(script) = $(variableTarget) ;
+
+	HAIKU_VARIABLE_NAME on $(variableTarget) = $(variable) ;
+	AddTargetVariableToScript1 $(variableTarget) : $(initScript) $(targets) ;
 }
 
+
 actions AddTargetVariableToScript1
 {
-	echo "$(VARIABLE_NAME($(2:BS)))=\"$(2)\"" >> $(1)
+	script="$(2[1])"
+	echo "$(HAIKU_VARIABLE_NAME)=" >> "$script"
+
+	firstSeen=
+	for value in "$(2[2-])" ; do
+		if [ -z "$firstSeen" ]; then
+			echo "$(HAIKU_VARIABLE_NAME)=\"$value\"" >> "$script"
+			firstSeen=1
+		else
+			echo "$(HAIKU_VARIABLE_NAME)=\"\$$(HAIKU_VARIABLE_NAME) $value\"" \
+				>> "$script"
+		fi
+	done
 }
 
 
 #pragma mark -
 
-rule AddDirectoryToContainer container : directoryTokens
+rule AddDirectoryToContainer container : directoryTokens : attributeFiles
 {
-	# AddDirectoryToContainer <container> : <directoryTokens>
+	# AddDirectoryToContainer <container> : <directoryTokens> : <attributeFiles>
 
 	local containerGrist = [ on $(container) return $(HAIKU_CONTAINER_GRIST) ] ;
 	local directory = [ FDirName $(directoryTokens) ] ;
@@ -121,6 +140,12 @@ rule AddDirectoryToContainer container : directoryTokens
 		}
 	}
 
+	if $(attributeFiles) {
+		SEARCH on $(attributeFiles)
+			+= [ FDirName $(HAIKU_TOP) data image_directories ] ;
+		ATTRIBUTE_FILES on $(dir) += $(attributeFiles) ;
+	}
+
 	return $(directory) ;
 }
 
@@ -151,14 +176,26 @@ rule IncludeAllTargetsInContainer container
 }
 
 
+rule PropagateContainerUpdateTargetFlags toTarget : fromTarget
+{
+	if [ on $(fromTarget) return $(HAIKU_INCLUDE_IN_IMAGE) ] {
+		HAIKU_INCLUDE_IN_IMAGE on $(toTarget) = 1 ;
+	}
+
+	if [ on $(fromTarget) return $(HAIKU_INCLUDE_IN_PACKAGES) ] {
+		HAIKU_INCLUDE_IN_PACKAGES on $(toTarget) = 1 ;
+	}
+}
+
+
 rule AddFilesToContainer container : directoryTokens : targets : destName
 {
 	# AddFilesToContainer <container> : <directoryTokens> : <targets>
 	#	[ : dest name ]
 	#
-	local directory = [ AddDirectoryToContainer $(container)
-		: $(directoryTokens) ] ;
 	local containerGrist = [ on $(container) return $(HAIKU_CONTAINER_GRIST) ] ;
+	local systemDirTokens
+		= [ on $(container) return $(HAIKU_CONTAINER_SYSTEM_DIR_TOKENS) ] ;
 
 	targets = [ FFilterByBuildFeatures $(targets) ] ;
 
@@ -171,9 +208,28 @@ rule AddFilesToContainer container : directoryTokens : targets : destName
 		if $(filterVar) {
 			targets = [ FilterContainerUpdateTargets $(targets)
 				: $(filterVar) ] ;
+
+			# If there are any targets, mark the container as to be included in
+			# an update, too, if it has set the update inheritance variable.
+			# This makes updating a target that lives in a package on an image
+			# work.
+			if $(targets) {
+				local updateVariable = [ on $(container) return
+					$(HAIKU_CONTAINER_INHERIT_UPDATE_VARIABLE) ] ;
+				if $(updateVariable) {
+					$(updateVariable) on $(container) = 1 ;
+				}
+			}
 		}
 	}
 
+	if ! $(targets) {
+		return ;
+	}
+
+	local directory = [ AddDirectoryToContainer $(container)
+		: $(directoryTokens) ] ;
+
 	# We create a unique dummy target per target to install.
 	local installTargetsVar
 		= [ on $(container) return $(HAIKU_INSTALL_TARGETS_VAR) ] ;
@@ -197,9 +253,25 @@ rule AddFilesToContainer container : directoryTokens : targets : destName
 		if $(catalogs) {
 			local signature
 				= [ on $(target) return $(HAIKU_CATALOG_SIGNATURE) ] ;
-			AddFilesToHaikuImage system data locale catalogs $(signature)
+			AddFilesToContainer $(container)
+				: $(systemDirTokens) data locale catalogs $(signature)
 				: $(catalogs) ;
 		}
+
+		# If the target is associated with MIME DB entries, add those, too.
+		local mimeDBEntries = [ on $(target) return $(HAIKU_MIME_DB_ENTRIES) ] ;
+		if $(mimeDBEntries) {
+			# Make sure we add the entries only once by tracking the containers
+			# we have already added it to.
+			local containers = [ on $(mimeDBEntries)
+				return $(HAIKU_MIME_DB_ENTRIES_IN_CONTAINERS) ] ;
+			if ! $(container) in $(containers) {
+				HAIKU_MIME_DB_ENTRIES_IN_CONTAINERS on $(mimeDBEntries)
+					= $(containers) $(container) ;
+	 			CopyDirectoryToContainer $(container) : data
+ 					: $(mimeDBEntries) : mime_db : : alwaysUpdate isTarget ;
+ 			}
+		}
 	}
 }
 
@@ -255,60 +327,135 @@ rule FSymlinksInContainerDirectory container : directoryTokens
 }
 
 rule CopyDirectoryToContainer container : directoryTokens : sourceDirectory
-	: targetDirectoryName : excludePatterns : alwaysUpdate
+	: targetDirectoryName : excludePatterns : flags
 {
 	# CopyDirectoryToContainer <container> : <directoryTokens>
 	#	: <sourceDirectory> : <targetDirectoryName> : <excludePatterns>
-	#	: <alwaysUpdate> ;
+	#	[ : <flags> ] ;
 	#
+	# Supported flags: alwaysUpdate, isTarget
+	# isTarget: <sourceDirectory> is a target, not a path
 
 	# If the image shall only be updated, we don't copy any directories
 	if [ on $(container) return $(HAIKU_CONTAINER_UPDATE_ONLY) ]
 			&& ! [ IncludeAllTargetsInContainer $(container) ]
-			&& ! $(alwaysUpdate) {
+			&& ! alwaysUpdate in $(flags) {
 		return ;
 	}
 
 	if ! $(targetDirectoryName) {
-		local path = [ FReverse [ FSplitPath $(sourceDirectory) ] ] ;
+		targetDirectoryName = $(sourceDirectory[1]:BS) ;
-		targetDirectoryName = $(path[1]) ;
+	}
+
+	# If sourceDirectory is a path, not a target, make it a target, so we can
+	# treat both the same way.
+	if ! isTarget in $(flags) {
+		sourceDirectory = $(sourceDirectory:G=copy-directory-to-container) ;
+		SEARCH on $(sourceDirectory) = ;
+		TARGET on $(sourceDirectory) = ;
 	}
 
 	local directory = [ AddDirectoryToContainer $(container)
 		: $(directoryTokens) $(targetDirectoryName) ] ;
 
 	local targetDir = $(directory)/-/$(sourceDirectory) ;
+	Depends $(targetDir) : $(sourceDirectory) ;
 	EXCLUDE_PATTERNS on $(targetDir) = $(excludePatterns) ;
 	SOURCE_DIRECTORY on $(targetDir) = $(sourceDirectory) ;
 	TARGET_DIRECTORY on $(targetDir) = $(directory) ;
 	DIRECTORIES_TO_INSTALL on $(directory) += $(targetDir) ;
 }
 
+
+rule AddHeaderDirectoryToContainer container : dirTokens : dirName
+	: flags
+{
+	# AddHeaderDirectoryToContainer <container> : <dirTokens> : [ <dirName> ]
+	#	[ : <flags> ] ;
+	#
+	# Supported flags: alwaysUpdate
+
+	local systemDirTokens
+		= [ on $(container) return $(HAIKU_CONTAINER_SYSTEM_DIR_TOKENS) ] ;
+
+	CopyDirectoryToContainer $(container) : $(systemDirTokens) develop headers
+		: [ FDirName $(HAIKU_TOP) headers $(dirTokens) ]
+		: $(dirName) : -x .svn : $(flags) ;
+}
+
+
+rule AddWifiFirmwareToContainer container : driver : package : archive : extract
+{
+	# AddWifiFirmwareToContainer <container> : <driver> : <package> : <archive>
+	#	: <extract>
+
+	# complete location to wifi firmware archive
+	local firmwareArchive = [ FDirName
+		$(HAIKU_TOP) data system data firmware $(driver) $(archive) ] ;
+
+	local systemDirTokens
+		= [ on $(container) return $(HAIKU_CONTAINER_SYSTEM_DIR_TOKENS) ] ;
+
+	local dirTokens = $(systemDirTokens) data firmware $(driver) ;
+	if $(extract) = true || $(extract) = 1 {
+		ExtractArchiveToContainer $(container) : $(dirTokens)
+			: $(firmwareArchive) : : $(package) ;
+	} else {
+		AddFilesToContainer $(container) : $(dirTokens) : $(firmwareArchive)  ;
+	}
+}
+
+
 rule ExtractArchiveToContainer container : directoryTokens : archiveFile
-	: extractedSubDir : stripDebugSymbols
+	: flags : extractedSubDir
 {
 	# ExtractArchiveToContainer <container> : <directory> : <archiveFile>
-	#	: <extractedSubDir> : <stripDebugSymbols> ;
+	#	: [ <flags> ] : <extractedSubDir> ;
+	#
+	# Supported flags: alwaysUpdate
+
+	# If the container shall only be updated, we extract only, if explicitely
+	# requested.
+	if [ on $(container) return $(HAIKU_CONTAINER_UPDATE_ONLY) ]
+		&& ! alwaysUpdate in $(flags) {
+		return ;
+	}
 
 	local directory = [ AddDirectoryToContainer $(container)
 		: $(directoryTokens) ] ;
 
 	ARCHIVE_FILES_TO_INSTALL on $(directory) += $(archiveFile) ;
 	ARCHIVE_SUBDIR_TO_INSTALL_FROM on $(archiveFile) = $(extractedSubDir) ;
-	ARCHIVE_FILES_TO_STRIP on $(archiveFile) = $(stripDebugSymbols) ;
 }
 
 rule AddDriversToContainer container : relativeDirectoryTokens : targets
 {
 	# AddDriversToContainer <container> : <relative directory> : <targets> ;
 	#
-	local directoryTokens = system add-ons kernel drivers dev
+	local systemDirTokens
+		= [ on $(container) return $(HAIKU_CONTAINER_SYSTEM_DIR_TOKENS) ] ;
+	local directoryTokens = $(systemDirTokens) add-ons kernel drivers dev
 		$(relativeDirectoryTokens) ;
 
 	targets = [ FFilterByBuildFeatures $(targets) ] ;
 
-	AddFilesToContainer $(container) : system add-ons kernel drivers bin
+	# A driver can be in multiple categories. Avoid adding it to the bin/
-		: $(targets) ;
+	# directory more than once.
+	local binTargets ;
+	local target ;
+	for target in $(targets) {
+		local containers
+			= [ on $(target) return $(HAIKU_DRIVER_IN_CONTAINERS) ] ;
+		if ! $(container) in $(containers) {
+			HAIKU_DRIVER_IN_CONTAINERS on $(target)
+				= $(containers) $(container) ;
+			binTargets += $(target) ;
+		}
+	}
+
+	AddFilesToContainer $(container)
+		: $(systemDirTokens) add-ons kernel drivers bin
+		: $(binTargets) ;
 
 	# If the image shall only be updated, we don't add any symlinks.
 	if [ on $(container) return $(HAIKU_CONTAINER_UPDATE_ONLY) ]
@@ -336,7 +483,9 @@ rule AddNewDriversToContainer container : relativeDirectoryTokens
 {
 	# AddNewDriversToContainer <container> : <directory> : <targets> ;
 	#
-	local directoryTokens = system add-ons kernel drivers
+	local systemDirTokens
+		= [ on $(container) return $(HAIKU_CONTAINER_SYSTEM_DIR_TOKENS) ] ;
+	local directoryTokens = $(systemDirTokens) add-ons kernel drivers
 		$(relativeDirectoryTokens) ;
 
 	targets = [ FFilterByBuildFeatures $(targets) ] ;
@@ -350,12 +499,15 @@ rule AddBootModuleSymlinksToContainer container : targets
 	# AddBootModuleSymlinksToContainer <container> : <targets> ;
 	#
 
-	# If the image shall only be updated, we don't add any symlinks.
+	# If the container shall only be updated, we don't add any symlinks.
+
 	if [ on $(container) return $(HAIKU_CONTAINER_UPDATE_ONLY) ]
 		&& ! [ IncludeAllTargetsInContainer $(container) ] {
 		return ;
 	}
 
+	local systemDirTokens
+		= [ on $(container) return $(HAIKU_CONTAINER_SYSTEM_DIR_TOKENS) ] ;
 	targets = [ FFilterByBuildFeatures $(targets) ] ;
 
 	# add the symlinks
@@ -373,15 +525,46 @@ rule AddBootModuleSymlinksToContainer container : targets
 			Exit "ERROR: Add*ToContainer has not been invoked for it yet." ;
 		}
 
-		local name = $(target:BS) ;
+		# chop off the system dir prefix from installDir
-		local linkTarget = [ FDirName /boot $(installDir:G=) $(name) ] ;
+		installDir = [ on $(installDir) return $(DIRECTORY_TOKENS) ] ;
+		local dummy ;
+		for dummy in $(systemDirTokens) {
+			installDir = $(installDir[2-]) ;
+		}
 
-		AddSymlinkToContainer $(container) : system add-ons kernel boot
+		local name = $(target:BS) ;
+		local linkTarget = [ FDirName ../../.. $(installDir) $(name) ] ;
+
+		AddSymlinkToContainer $(container)
+			: $(systemDirTokens) add-ons kernel boot
 			: $(linkTarget) : $(name) ;
 	}
 }
 
 
+rule AddLibrariesToContainer container : directory : libs
+{
+	# AddLibrariesToContainer <container> : <directory> : <libs>
+	#
+	# Installs libraries with the appropriate links into the container.
+	#
+
+	local lib ;
+	for lib in $(libs) {
+		local abiVersion = [ on $(lib) return $(HAIKU_LIB_ABI_VERSION) ] ;
+		if $(abiVersion) {
+			local abiVersionedLib = $(lib:G=).$(abiVersion) ;
+			AddFilesToContainer $(container) : $(directory) : $(lib)
+				: $(abiVersionedLib) ;
+			AddSymlinkToContainer $(container) : $(directory)
+				: $(abiVersionedLib) : $(lib:G=) ;
+		} else {
+			AddFilesToContainer $(container) : $(directory) : $(lib) ;
+		}
+	}
+}
+
+
 rule CreateContainerMakeDirectoriesScript container : script
 {
 	MakeLocate $(script) : $(HAIKU_OUTPUT_DIR) ;
@@ -409,7 +592,9 @@ rule CreateContainerMakeDirectoriesScript container : script
 	# If the image shall only be updated, we don't create directories.
 	if $(dirsToCreate)
 		&& ( ! [ on $(container) return $(HAIKU_CONTAINER_UPDATE_ONLY) ]
-			|| [ IncludeAllTargetsInContainer $(container) ] ) {
+			|| [ IncludeAllTargetsInContainer $(container) ]
+			|| [ on $(container) return
+				$(HAIKU_CONTAINER_ALWAYS_CREATE_DIRECTORIES) ] ) {
 		Depends $(scriptBody) : $(dirsToCreate) ;
 		CreateContainerMakeDirectoriesScript1 $(scriptBody) : $(dirsToCreate) ;
 
@@ -574,7 +759,7 @@ actions AddSymlinkToContainerCopyFilesScript
 }
 
 
-actions AddDirectoryToContainerCopyFilesScript
+actions AddDirectoryToContainerCopyFilesScript bind SOURCE_DIRECTORY
 {
 	echo \$cp -r $(EXCLUDE_PATTERNS) "\"\${sPrefix}$(SOURCE_DIRECTORY)/.\"" \
 		"\"\${tPrefix}$(TARGET_DIRECTORY:G=)\"" >> $(2[1])
@@ -616,11 +801,6 @@ rule CreateContainerExtractFilesScript container : script
 			ARCHIVE_SUBDIR_TO_INSTALL_FROM on $(dummyTarget) =
 				$(extractedSubDir:E=.) ;
 
-			local stripDebugSymbols = [ on $(archiveFile)
-				return $(ARCHIVE_FILES_TO_STRIP) ] ;
-			STRIP_DEBUG_SYMBOLS_FROM_ARCHIVE on $(dummyTarget) =
-				$(stripDebugSymbols) ;
-
 			Depends $(dummyTarget) : $(initScript) $(archiveFile)
 				$(serializationDependency) ;
 			Depends $(script) : $(dummyTarget) ;
@@ -636,8 +816,63 @@ rule CreateContainerExtractFilesScript container : script
 actions AddExtractFileToContainerExtractFilesScript
 {
 	echo extractFile "\"$(2[2])\"" "\"$(TARGET_DIR)\"" \
-		"\"$(ARCHIVE_SUBDIR_TO_INSTALL_FROM)\"" \
+		"\"$(ARCHIVE_SUBDIR_TO_INSTALL_FROM)\"" >> $(2[1])
-		"\"$(STRIP_DEBUG_SYMBOLS_FROM_ARCHIVE)\"" >> $(2[1])
+}
+
+
+rule AddPackagesAndRepositoryVariablesToContainerScript script : container
+{
+	AddVariableToScript $(script) : downloadDir : $(HAIKU_DOWNLOAD_DIR) ;
+	AddTargetVariableToScript $(script) : <build>package ;
+	AddTargetVariableToScript $(script) : <build>get_package_dependencies
+		: getPackageDependencies ;
+
+	# Add a variable to indicate whether packages dependencies shall be
+	# resolved. We always want to do that in non-update mode, but also in update
+	# mode when all packages are updated.
+	local updateOnly
+		= [ on $(container) return $(HAIKU_CONTAINER_UPDATE_ONLY) ] ;
+	local resolvePackageDependencies ;
+	if ( ! $(updateOnly) || $(HAIKU_UPDATE_ALL_PACKAGES) )
+		&& ! $(HAIKU_BOOTSTRAP_BUILD) {
+		resolvePackageDependencies = 1 ;
+	}
+	AddVariableToScript $(script) : resolvePackageDependencies
+		: $(resolvePackageDependencies) ;
+
+	# Add variables "systemPackages" and "commonPackages" with the packages
+	# copied/updated.
+	local allPackages = [ on $(container) return $(HAIKU_PACKAGES_IN_IMAGE) ] ;
+	if $(updateOnly) && ! [ IncludeAllTargetsInContainer $(container) ] {
+		allPackages = [ FilterContainerUpdateTargets $(allPackages)
+			: [ on $(container) return $(HAIKU_INCLUDE_IN_CONTAINER_VAR) ] ] ;
+	}
+
+	local systemPackages ;
+	local commonPackages ;
+	local package ;
+	for package in $(allPackages) {
+		if [ on $(package) return $(HAIKU_PACKAGE_INSTALLATION_LOCATION) ]
+				= system {
+			systemPackages += $(package) ;
+		} else {
+			commonPackages += $(package) ;
+		}
+	}
+
+	AddTargetVariableToScript $(script) : $(systemPackages) : systemPackages ;
+	AddTargetVariableToScript $(script) : $(commonPackages) : commonPackages ;
+
+	# Generate the repository package lists and add variables for the
+	# repositories.
+	local repository ;
+	local repositoryFiles ;
+	for repository in $(HAIKU_REPOSITORIES) {
+		repositoryFiles
+			+= [ on $(repository) return $(HAIKU_REPOSITORY_CACHE_FILE) ] ;
+	}
+
+	AddTargetVariableToScript $(script) : $(repositoryFiles) : repositories ;
 }
 
 
@@ -655,18 +890,10 @@ rule IsUpdateHaikuImageOnly
 
 rule AddDirectoryToHaikuImage directoryTokens : attributeFiles
 {
-	# AddDirectoryToHaikuImage <directoryTokens>
+	# AddDirectoryToHaikuImage <directoryTokens> : <attributeFiles>
 
-	local dir = [ AddDirectoryToContainer $(HAIKU_IMAGE_CONTAINER_NAME)
+	return [ AddDirectoryToContainer $(HAIKU_IMAGE_CONTAINER_NAME)
-		: $(directoryTokens) ] ;
+		: $(directoryTokens) : $(attributeFiles) ] ;
-
-	if $(attributeFiles) {
-		SEARCH on $(attributeFiles)
-			+= [ FDirName $(HAIKU_TOP) data image_directories ] ;
-		ATTRIBUTE_FILES on $(dir) += $(attributeFiles) ;
-	}
-
-	return $(dir) ;
 }
 
 rule AddFilesToHaikuImage directory : targets : destName
@@ -700,61 +927,47 @@ rule FSymlinksInHaikuImageDirectory directoryTokens
 }
 
 rule CopyDirectoryToHaikuImage directoryTokens : sourceDirectory
-	: targetDirectoryName : excludePatterns : alwaysUpdate
+	: targetDirectoryName : excludePatterns : flags
 {
 	CopyDirectoryToContainer $(HAIKU_IMAGE_CONTAINER_NAME) : $(directoryTokens)
 		: $(sourceDirectory) : $(targetDirectoryName) : $(excludePatterns)
-		: $(alwaysUpdate) ;
+		: $(flags) ;
 }
 
-rule AddSourceDirectoryToHaikuImage dirTokens : alwaysUpdate
+rule AddSourceDirectoryToHaikuImage dirTokens : flags
 {
-	# AddSourceDirectoryToHaikuImage <dirTokens> : <alwaysUpdate> ;
+	# AddSourceDirectoryToHaikuImage <dirTokens> : <flags> ;
 
 	CopyDirectoryToHaikuImage home HaikuSources
 		: [ FDirName $(HAIKU_TOP) $(dirTokens) ]
-		: : : $(alwaysUpdate) ;
+		: : : $(flags) ;
 }
 
-rule AddHeaderDirectoryToHaikuImage dirTokens : dirName : alwaysUpdate
+rule AddHeaderDirectoryToHaikuImage dirTokens : dirName : flags
 {
 	# AddHeaderDirectoryToHaikuImage <dirTokens> : [ <dirName> ]
-	#	: <alwaysUpdate> ;
+	#	: <flags> ;
 
-	CopyDirectoryToHaikuImage develop headers
+	AddHeaderDirectoryToContainer $(HAIKU_IMAGE_CONTAINER_NAME) : $(dirTokens)
-		: [ FDirName $(HAIKU_TOP) headers $(dirTokens) ]
+		: $(dirName) : $(flags) ;
-		: $(dirName) : : $(alwaysUpdate) ;
 }
 
 rule AddWifiFirmwareToHaikuImage driver : package : archive : extract
 {
-	#AddWifiFirmwareToHaikuImage <driver> : <package> : <archive> : <extract>
+	# AddWifiFirmwareToHaikuImage <driver> : <package> : <archive> : <extract>
 
-	# complete location to wifi firmware archive
+	AddWifiFirmwareToHaikuImage $(HAIKU_IMAGE_CONTAINER_NAME) : $(driver)
-	local firmwareArchive = [ FDirName
+		: $(package) : $(archive) : $(extract) ;
-		$(HAIKU_TOP) data system data firmware $(driver) $(archive) ] ;
-
-	local dirTokens = system data firmware $(driver) ;
-	if $(extract) = true || $(extract) = 1 {
-		ExtractArchiveToHaikuImage $(dirTokens) : $(firmwareArchive) :
-			: $(package) ;
-	} else {
-		AddFilesToHaikuImage $(dirTokens) : $(firmwareArchive)  ;
-	}
 }
 
-rule ExtractArchiveToHaikuImage dirTokens : archiveFile : alwaysUpdate
+rule ExtractArchiveToHaikuImage dirTokens : archiveFile : flags
-	: extractedSubDir : stripDebugSymbols
+	: extractedSubDir
 {
-	# ExtractArchiveToHaikuImage <dirTokens> : <archiveFile> : <alwaysUpdate>
+	# ExtractArchiveToHaikuImage <dirTokens> : <archiveFile> : <flags>
 	#	: <extractedSubDir> ;
 
-	# If the image shall only be updated, we extract only, if explicitely
+	ExtractArchiveToContainer $(HAIKU_IMAGE_CONTAINER_NAME) : $(dirTokens)
-	# requested.
+		: $(archiveFile) : $(flags) : $(extractedSubDir) ;
-	if ! [ IsUpdateHaikuImageOnly ] || $(alwaysUpdate) {
-		ExtractArchiveToContainer $(HAIKU_IMAGE_CONTAINER_NAME) : $(dirTokens)
-			: $(archiveFile) : $(extractedSubDir) : $(stripDebugSymbols) ;
-	}
 }
 
 rule AddDriversToHaikuImage relativeDirectoryTokens : targets
@@ -781,6 +994,16 @@ rule AddBootModuleSymlinksToHaikuImage targets
 		: $(targets) ;
 }
 
+rule AddPackageFilesToHaikuImage location : packages
+{
+	packages = [ FFilterByBuildFeatures $(packages) ] ;
+	HAIKU_PACKAGES_IN_IMAGE on $(HAIKU_IMAGE_CONTAINER_NAME)
+		= [ on $(HAIKU_IMAGE_CONTAINER_NAME) return $(HAIKU_PACKAGES_IN_IMAGE) ]
+			$(packages) ;
+	HAIKU_PACKAGE_INSTALLATION_LOCATION on $(packages) = $(location) ;
+	AddFilesToHaikuImage $(location) packages : $(packages) ;
+}
+
 rule AddOptionalHaikuImagePackages packages
 {
 	local package ;
@@ -828,6 +1051,82 @@ rule OptionalPackageDependencies package : dependencies
 	}
 }
 
+
+rule AddHaikuImagePackages packages : installationLocation
+{
+	# AddHaikuImagePackages <packages> [ : <installationLocation> ] ;
+	 # Adds the given package <packages>s to the image. <installationLocation>
+	 # is either "system" or "common" (the default) and specifies where the
+	 # packages shall be installed.
+
+	installationLocation ?= common ;
+
+	packages = [ FFilterByBuildFeatures $(packages) ] ;
+
+	local package ;
+	for package in $(packages) {
+		local resolvedPackage = [ IsPackageAvailable $(package) ] ;
+		if ! $(resolvedPackage) {
+			Echo "AddHaikuImagePackages: package" $(package)
+				"not available!" ;
+			continue ;
+		}
+
+		if ! [ on $(resolvedPackage) return $(HAIKU_PACKAGE_ADDED) ] {
+			HAIKU_PACKAGE_ADDED on $(resolvedPackage) = 1 ;
+			HAIKU_ADDED_PACKAGES += $(resolvedPackage) ;
+
+			# download the package file and add it to the image
+			local file = [ FetchPackage $(package) ] ;
+
+			if $(HAIKU_UPDATE_ALL_PACKAGES) {
+				HAIKU_INCLUDE_IN_IMAGE on $(file) = 1 ;
+			}
+
+			AddPackageFilesToHaikuImage $(installationLocation) : $(file) ;
+		}
+	}
+}
+
+
+rule IsHaikuImagePackageAdded package
+{
+	local resolvedPackage = [ IsPackageAvailable $(package) ] ;
+	if $(resolvedPackage)
+		&& [ on $(resolvedPackage) return $(HAIKU_PACKAGE_ADDED) ] {
+		return 1 ;
+	}
+
+	return ;
+}
+
+
+rule BuildHaikuImagePackageList target
+{
+	if ! $(target) {
+		return ;
+	}
+
+	# get the file names of all added packages
+	local packageFiles ;
+	local package ;
+	for package in $(HAIKU_ADDED_PACKAGES) {
+		packageFiles += [ FetchPackage $(package) : nameResolved ] ;
+	}
+
+	# extract the versioned package names (without revision)
+	packageFiles = [ Match "(.*)-[^-]*-[^-]*" : $(packageFiles:B) ] ;
+
+	HAIKU_IMAGE_PACKAGES on $(target) = $(packageFiles) ;
+}
+
+
+actions BuildHaikuImagePackageList
+{
+	echo $(HAIKU_IMAGE_PACKAGES) | xargs -n 1 echo | LC_ALL=C sort -u > $(1)
+}
+
+
 rule InstallSourceArchive file : url
 {
 	if $(HAIKU_INCLUDE_SOURCES) = 1 {
@@ -839,29 +1138,41 @@ rule InstallSourceArchive file : url
 	}
 }
 
-rule InstallOptionalHaikuImagePackage package : url : dirTokens : isCDPackage
+rule InstallOptionalHaikuImagePackage url : dirTokens : flags
-	: stripDebugSymbols
 {
+	# TODO: Remove the non-hpkg cases!
+	# Currently the semantics differs depending on whether the  cdPackage flag
+	# has been specified and the type of the package file:
+	# * For a hpkg <dirTokens> is "common" (default) or "system" and specifies
+	#   the installation location of the package (will be copied to the
+	#   packages/ subdirectory).
+	# * For a regular archive and cdPackage, <dirTokens> is ignored and
+	#   the package will be copied to the _package_ directory of the CD image.
+	# * For a regular archive and without cdPackage, <dirTokens> specifies the
+	#   directory relative to the image's root directory where the content of
+	#   the archive will be extracted to.
+	#
+	# Supported flags: cdPackage
+
+	local package = $(url:BS) ;
+
 	# download archive file
 	local archiveFile = [ DownloadFile $(package) : $(url) ] ;
 
-	if ( $(isCDPackage) = true || $(isCDPackage) = 1 ) && $(HAIKU_CD_NAME) {
+	if $(package:S) = .hpkg {
+		local location = $(dirTokens:E=common) ;
+		if $(HAIKU_UPDATE_ALL_PACKAGES) {
+			HAIKU_INCLUDE_IN_IMAGE on $(archiveFile) = 1 ;
+		}
+		AddPackageFilesToHaikuImage $(location) : $(archiveFile) ;
+	} else if cdPackage in $(flags) && $(HAIKU_CD_NAME) {
 		# TODO: If HAIKU_CD_NAME is set, that doesn't mean we're building a CD
 		# image!
 		# copy onto image
 		AddFilesToHaikuImage _packages_ : $(archiveFile) ;
 	} else {
-		if $(HAIKU_STRIP_DEBUG_FROM_OPTIONAL_PACKAGES) = 1 {
-			stripDebugSymbols ?= 1 ;
-			# The script will only test for = 1. This is in case someone
-			# manually set the flag 'true'
-			if $(stripDebugSymbols) = true {
-				stripDebugSymbols = 1 ;
-			}
-		}
 		# extract onto image
-		ExtractArchiveToHaikuImage $(dirTokens) : $(archiveFile)
+		ExtractArchiveToHaikuImage $(dirTokens) : $(archiveFile) : $(flags) ;
-			: : : $(stripDebugSymbols) ;
 	}
 }
 
@@ -877,7 +1188,7 @@ rule AddEntryToHaikuImageUserGroupFile file : entry
 		Always $(file) ;
 		MakeLocate $(file) : $(HAIKU_COMMON_PLATFORM_OBJECT_DIR) ;
 		BuildHaikuImageUserGroupFile $(file) ;
-		AddFilesToHaikuImage common etc : $(file) ;
+		AddFilesToHaikuImage common settings etc : $(file) ;
 	}
 
 	HAIKU_IMAGE_USER_GROUP_ENTRIES on $(file) = $(allEntries) ;
@@ -912,80 +1223,16 @@ rule AddGroupToHaikuImage group : gid : members
 	AddEntryToHaikuImageUserGroupFile <haiku-image>group : $(entry) ;
 }
 
-rule AddEntryToHaikuImageExpanderRuleFile file : entry
+
+rule AddLibrariesToHaikuImage directory : libs
 {
-	local allEntries
+	# AddLibraryToHaikuImage <directory> : <libs>
-		= [ on $(file) return $(HAIKU_IMAGE_EXPANDER_RULES_ENTRIES) ] ;
+	#
+	# Installs libraries with the appropriate links onto the image.
+	#
 
-	if $(allEntries) {
+	AddLibrariesToContainer $(HAIKU_IMAGE_CONTAINER_NAME) : $(directory)
-		allEntries = $(allEntries)!$(entry) ;
+		: $(libs) ;
-	} else {
-		allEntries = $(entry) ;
-
-		Always $(file) ;
-		MakeLocate $(file) : $(HAIKU_COMMON_PLATFORM_OBJECT_DIR) ;
-		BuildHaikuImageExpanderRules $(file) ;
-		AddFilesToHaikuImage common data : $(file) ;
-	}
-
-	HAIKU_IMAGE_EXPANDER_RULES_ENTRIES on $(file) = $(allEntries) ;
-}
-
-actions BuildHaikuImageExpanderRules
-{
-	echo -e "$(HAIKU_IMAGE_EXPANDER_RULES_ENTRIES)" | tr '!' '\n' > $(1)
-}
-
-rule AddExpanderRuleToHaikuImage mimetype : extension : list : extract
-{
-	#AddExpanderRuleToHaikuImage <mimetype> : <extension> : <list> : <extract>
-
-	if ! $(mimetype) || ! $(extension) || ! $(list) || ! $(extract) {
-		Exit "Invalid expander rule specification passed to AddExpanderRule." ;
-	}
-
-	local entry
-		= "\\\"$(mimetype)\\\"\\\t$(extension)\\\t\\\"$(list)\\\"\\\t\\\"$(extract)\\\"" ;
-	AddEntryToHaikuImageExpanderRuleFile <haiku-image>expander.rules
-		: $(entry) ;
-}
-
-rule AddInstalledPackagesFileToHaikuImage
-{
-	#AddInstalledPackagesFileToHaikuImage
-	local file = <haiku-image>InstalledPackages ;
-
-	Always $(file) ;
-	MakeLocate $(file) : $(HAIKU_COMMON_PLATFORM_OBJECT_DIR) ;
-	BuildHaikuImageInstalledPackagesFile $(file) ;
-	AddFilesToHaikuImage common data optional-packages : $(file) ;
-}
-
-actions BuildHaikuImageInstalledPackagesFile
-{
-	echo -e "$(HAIKU_ADDED_OPTIONAL_PACKAGES)" | tr '\ ' '\n'  > $(1)
-}
-
-rule AddOptionalPackageDescriptionToHaikuImage file : searchPath
-{
-	if $(searchPath) {
-		SEARCH on $(file) = [ FDirName $(searchPath) ] ;
-	}
-
-	HAIKU_IMAGE_OPTIONAL_PACKAGE_DESCRIPTIONS += $(file) ;
-}
-
-rule AddLicenseToHaikuImage file : name : searchPath
-{
-	if $(searchPath) {
-		SEARCH on $(file) = [ FDirName $(searchPath) ] ;
-	}
-
-	if $(name) && $(file:BS) = $(name) {
-		name = ;
-	}
-
-	AddFilesToHaikuImage system data licenses : $(file) : $(name) ;
 }
 
 
@@ -1144,160 +1391,6 @@ actions BuildNetBootArchive1
 }
 
 
-#pragma mark - Alternative GCC Archive rules
-
-
-rule AddDirectoryToAlternativeGCCArchive directoryTokens
-{
-	# AddDirectoryToAlternativeGCCArchive <directoryTokens>
-
-	return [ AddDirectoryToContainer
-		$(HAIKU_ALTERNATIVE_GCC_ARCHIVE_CONTAINER_NAME) : $(directoryTokens) ] ;
-}
-
-rule AddFilesToAlternativeGCCArchive directory : targets : destName
-{
-	# AddFilesToAlternativeGCCArchive <directory> : <targets> [ : dest name ]
-
-	AddFilesToContainer $(HAIKU_ALTERNATIVE_GCC_ARCHIVE_CONTAINER_NAME)
-		: $(directory) : $(targets) : $(destName) ;
-}
-
-rule AddSymlinkToAlternativeGCCArchive directoryTokens : linkTarget : linkName
-{
-	# AddSymlinkToAlternativeGCCArchive <directory> : <link target>
-	#	[ : <link name> ] ;
-
-	AddSymlinkToContainer $(HAIKU_ALTERNATIVE_GCC_ARCHIVE_CONTAINER_NAME)
-		: $(directoryTokens) : $(linkTarget) : $(linkName) ;
-}
-
-rule CopyDirectoryToAlternativeGCCArchive directoryTokens : sourceDirectory
-	: targetDirectoryName : excludePatterns : alwaysUpdate
-{
-	CopyDirectoryToContainer $(HAIKU_ALTERNATIVE_GCC_ARCHIVE_CONTAINER_NAME)
-		: $(directoryTokens) : $(sourceDirectory) : $(targetDirectoryName)
-		: $(excludePatterns) : $(alwaysUpdate) ;
-}
-
-rule CreateAlternativeGCCArchiveMakeDirectoriesScript script
-{
-	CreateContainerMakeDirectoriesScript
-		$(HAIKU_ALTERNATIVE_GCC_ARCHIVE_CONTAINER_NAME) : $(script) ;
-}
-
-rule CreateAlternativeGCCArchiveCopyFilesScript script
-{
-	CreateContainerCopyFilesScript
-		$(HAIKU_ALTERNATIVE_GCC_ARCHIVE_CONTAINER_NAME) : $(script) ;
-}
-
-rule BuildAlternativeGCCArchive archive : scripts
-{
-	# BuildAlternativeGCCArchive <archive> : <scripts>  ;
-
-	local mainScript = build_archive ;
-	SEARCH on $(mainScript) = [ FDirName $(HAIKU_TOP) build scripts ] ;
-
-	Depends $(archive) : $(mainScript) $(scripts) ;
-	BuildAlternativeGCCArchive1 $(archive) : $(mainScript) $(scripts) ;
-}
-
-actions BuildAlternativeGCCArchive1
-{
-	$(2[1]) $(1) $(2[2-])
-}
-
-
-#pragma mark - Haiku Hybrid Image rules
-
-
-rule AddFilesToHaikuHybridImage directory : targets : destName
-	: useABISubDir
-{
-	# AddFilesToHaikuHybridImage <directory> : <targets> : <destName>
-	#	: <useABISubDir>
-	#
-	# Convenience rule calling both AddFilesToHaikuImage and
-	# AddFilesToAlternativeGCCArchive.
-	#
-	# <useABISubDir>
-	#	if non-empty, specifies that an ABI subdirectory shall be appended to
-	#	<directory> for the alternative GCC archive.
-
-	local alternativeSubDir ;
-	if $(useABISubDir) {
-		alternativeSubDir = gcc$(HAIKU_GCC_VERSION[1]) ;
-	}
-
-	AddFilesToHaikuImage $(directory) : $(targets) : $(destName) ;
-	AddFilesToAlternativeGCCArchive $(directory) $(alternativeSubDir)
-		: $(targets) : $(destName) ;
-}
-
-rule AddSymlinkToHaikuHybridImage directoryTokens : linkTarget : linkName
-	: useSymlinkTargetABISubDir : useABISubDir
-{
-	# AddSymlinkToHaikuHybridImage <directoryTokens> : <linkTarget> : <linkName>
-	#	[ : <useSymlinkTargetABISubDir> [ :  <useABISubDir> ] ]
-	#
-	# Convenience rule calling both AddSymlinkToHaikuImage and
-	# AddSymlinkToAlternativeGCCArchive.
-	#
-	# <linkTarget>
-	#	Can be a list of components that will be joined to path inserting
-	#	"/"s inbetween.
-	# <useSymlinkTargetABISubDir>
-	#	If non-empty, specifies that an ABI subdirectory shall be inserted
-	#	into <linkTarget> (between the first and second component) for the
-	#	alternative GCC archive.
-	# <useABISubDir>
-	#	If non-empty, specifies that an ABI subdirectory part shall be appended
-	#	to the directory tokens for the alternative GCC archive.
-
-	local alternativeDirTokens = $(directoryTokens) ;
-	if $(useABISubDir) {
-		alternativeDirTokens += gcc$(HAIKU_GCC_VERSION[1]) ;
-	}
-
-	local alternativeLinkTarget = $(linkTarget) ;
-	if $(useSymlinkTargetABISubDir) {
-		alternativeLinkTarget = $(linkTarget[1]) gcc$(HAIKU_GCC_VERSION[1])
-			$(linkTarget[2-]) ;
-	}
-	linkTarget = $(linkTarget:J=/) ;
-	alternativeLinkTarget = $(alternativeLinkTarget:J=/) ;
-
-	AddSymlinkToHaikuImage $(directoryTokens) : $(linkTarget) : $(linkName) ;
-	AddSymlinkToAlternativeGCCArchive $(alternativeDirTokens)
-		: $(alternativeLinkTarget) : $(linkName) ;
-}
-
-rule AddLibrariesToHaikuHybridImage directory : libs
-{
-	# AddLibraryToHaikuHybridImage <directory> : <libs>
-	#
-	# Installs libraries with the appropriate links onto the image.
-	#
-
-	libs = [ FFilterByBuildFeatures $(libs) ] ;
-
-	local lib ;
-	for lib in $(libs) {
-		local abiVersion = [ on $(lib) return $(HAIKU_LIB_ABI_VERSION) ] ;
-		if $(abiVersion) {
-			local abiVersionedLib = $(lib).$(abiVersion) ;
-			AddFilesToHaikuHybridImage $(directory)
-				: $(lib) : $(abiVersionedLib) : true ;
-			AddSymlinkToHaikuHybridImage $(directory)
-				: $(abiVersionedLib) : $(lib) : : true ;
-		} else {
-			AddFilesToHaikuHybridImage $(directory) : $(lib) : : true ;
-		}
-	}
-}
-
-
 #pragma mark - Floppy Boot Archive rules
 
 

build/jam/KernelRules

@@ -23,8 +23,9 @@ rule SetupKernel
 		ObjectDefines $(object) : $(TARGET_KERNEL_DEFINES) ;
 
 		# override warning flags
-		TARGET_WARNING_CCFLAGS on $(object) = $(TARGET_KERNEL_WARNING_CCFLAGS) ;
+		TARGET_WARNING_CCFLAGS_$(TARGET_PACKAGING_ARCH) on $(object)
-		TARGET_WARNING_C++FLAGS on $(object)
+			= $(TARGET_KERNEL_WARNING_CCFLAGS) ;
+		TARGET_WARNING_C++FLAGS_$(TARGET_PACKAGING_ARCH) on $(object)
 			= $(TARGET_KERNEL_WARNING_C++FLAGS) ;
 	}
 }
@@ -39,7 +40,7 @@ rule KernelLd
 {
 	# KernelLd <name> : <objs> : <linkerscript> : <args> ;
 
-	LINK on $(1) = $(TARGET_LD) ;
+	LINK on $(1) = $(TARGET_LD_$(TARGET_PACKAGING_ARCH)) ;
 
 	LINKFLAGS on $(1) = $(4) ;
 	if $(3) { LINKFLAGS on $(1) += --script=$(3) ; }
@@ -92,7 +93,7 @@ actions KernelSo1
 	$(HOST_ADD_BUILD_COMPATIBILITY_LIB_DIR)
 
 	$(2[1]) --data $(2[2]) $(1) &&
-	$(HAIKU_ELFEDIT) --output-type dyn $(1)
+	$(HAIKU_ELFEDIT_$(TARGET_PACKAGING_ARCH)) --output-type dyn $(1)
 }
 
 rule KernelAddon
@@ -133,7 +134,7 @@ rule KernelAddon
 	Depends $(target) : $(beginGlue) $(endGlue) ;
 
 	# compile and link
-	SetupKernel $(sources) : $(TARGET_KERNEL_PIC_FLAGS) : false ;
+	SetupKernel $(sources) : : false ;
 	local linkFlags = -nostdlib -Xlinker --no-undefined
 		-Xlinker -soname=\"$(target:G=)\" $(TARGET_KERNEL_ADDON_LINKFLAGS) ;
 	LINKFLAGS on $(target) = [ on $(target) return $(LINKFLAGS) ] $(linkFlags) ;
@@ -161,7 +162,7 @@ rule KernelStaticLibrary
 {
 	# Usage KernelStaticLibrary <name> : <sources> : <extra cc flags>  ;
 	# This is designed to take a set of sources and libraries and create
-	# a file called lib<name>.a
+	# a static library.
 
 	SetupKernel $(2) : $(3) : false ;
 	Library $(1) : $(2) ;
@@ -187,5 +188,5 @@ actions KernelStaticLibraryObjects
 	# Force recreation of the archive to avoid build errors caused by
 	# stale dependencies after renaming or deleting object files.
 	$(RM) "$(1)"
-	$(HAIKU_AR) -r "$(1)" "$(2)" ;
+	$(HAIKU_AR_$(TARGET_PACKAGING_ARCH)) -r "$(1)" "$(2)" ;
 }

build/jam/LocaleRules

@@ -32,13 +32,17 @@ rule ExtractCatalogEntries target : sources : signature : regexp
 			localIncludesOption = $(HOST_LOCAL_INCLUDES_OPTION) ;
 			systemIncludesOption = $(HOST_SYSTEM_INCLUDES_OPTION) ;
 		} else {
-			sysHeaders += $(TARGET_HDRS) ;
+			sysHeaders += $(TARGET_HDRS_$(TARGET_PACKAGING_ARCH)) ;
-			defines += $(TARGET_DEFINES) ;
+			defines += $(TARGET_DEFINES_$(TARGET_PACKAGING_ARCH))
-			cc = $(TARGET_CC) ;
+				$(TARGET_DEFINES) ;
+			cc = $(TARGET_CC_$(TARGET_PACKAGING_ARCH)) ;
 
-			includesSeparator = $(TARGET_INCLUDES_SEPARATOR) ;
+			includesSeparator
-			localIncludesOption = $(TARGET_LOCAL_INCLUDES_OPTION) ;
+				= $(TARGET_INCLUDES_SEPARATOR_$(TARGET_PACKAGING_ARCH)) ;
-			systemIncludesOption = $(TARGET_SYSTEM_INCLUDES_OPTION) ;
+			localIncludesOption
+				= $(TARGET_LOCAL_INCLUDES_OPTION_$(TARGET_PACKAGING_ARCH)) ;
+			systemIncludesOption
+				= $(TARGET_SYSTEM_INCLUDES_OPTION_$(TARGET_PACKAGING_ARCH)) ;
 		}
 	}
 

build/jam/MainBuildRules

@@ -9,15 +9,10 @@ rule AddSharedObjectGlueCode
 	on $(1) {
 		platform = $(PLATFORM) ;
 		if $(platform) = haiku {
-			local stdLibs = libroot.so ;
+			local stdLibs = [ MultiArchDefaultGristFiles libroot.so ] ;
-			local beginGlue ;
+			local type = EXECUTABLE ;
-			local endGlue ;
+			if $(2) != true {
-			if $(2) = true {
+				type = LIBRARY ;
-				beginGlue += $(HAIKU_EXECUTABLE_BEGIN_GLUE_CODE) ;
-				endGlue += $(HAIKU_EXECUTABLE_END_GLUE_CODE) ;
-			} else {
-				beginGlue += $(HAIKU_LIBRARY_BEGIN_GLUE_CODE) ;
-				endGlue += $(HAIKU_LIBRARY_END_GLUE_CODE) ;
 
 				# special case for libroot: don't link it against itself
 				if $(DONT_LINK_AGAINST_LIBROOT) {
@@ -25,6 +20,11 @@ rule AddSharedObjectGlueCode
 				}
 			}
 
+			local beginGlue
+				= $(HAIKU_$(type)_BEGIN_GLUE_CODE_$(TARGET_PACKAGING_ARCH)) ;
+			local endGlue
+				= $(HAIKU_$(type)_END_GLUE_CODE_$(TARGET_PACKAGING_ARCH)) ;
+
 			LINK_BEGIN_GLUE on $(1) = $(beginGlue) ;
 			LINK_END_GLUE on $(1) = $(endGlue) ;
 
@@ -209,9 +209,9 @@ rule Ld
 			LINK on $(target) = $(HOST_LD) ;
 			LINKFLAGS on $(target) = $(HOST_LDFLAGS) $(LINKFLAGS) $(linkerFlags) ;
 		} else {
-			LINK on $(target) = $(TARGET_LD) ;
+			LINK on $(target) = $(TARGET_LD_$(TARGET_PACKAGING_ARCH)) ;
-			LINKFLAGS on $(target) = $(TARGET_LDFLAGS) $(LINKFLAGS)
+			LINKFLAGS on $(target) = $(TARGET_LDFLAGS_$(TARGET_PACKAGING_ARCH))
-				$(linkerFlags) ;
+				$(LINKFLAGS) $(linkerFlags) ;
 		}
 
 		NEEDLIBS on $(target) = $(NEEDLIBS) ;
@@ -275,8 +275,9 @@ rule CreateAsmStructOffsetsHeader header : source
 			}
 
 		} else {
-			sysHeaders += $(TARGET_HDRS) ;
+			sysHeaders += $(TARGET_HDRS_$(TARGET_PACKAGING_ARCH)) ;
-			defines += $(TARGET_DEFINES) ;
+			defines += $(TARGET_DEFINES_$(TARGET_PACKAGING_ARCH))
+				$(TARGET_DEFINES) ;
 		}
 
 		# optimization flags
@@ -309,18 +310,22 @@ rule CreateAsmStructOffsetsHeader header : source
 		} else {
 			# warning flags
 			if $(WARNINGS) != 0 {
-				flags += $(TARGET_WARNING_C++FLAGS) ;
+				flags += $(TARGET_WARNING_C++FLAGS_$(TARGET_PACKAGING_ARCH)) ;
 			}
 
 			# debug and other flags
-			flags += $(TARGET_C++FLAGS) $(TARGET_DEBUG_$(DEBUG)_C++FLAGS)
+			flags += $(TARGET_C++FLAGS_$(TARGET_PACKAGING_ARCH))
+				$(TARGET_DEBUG_$(DEBUG)_C++FLAGS_$(TARGET_PACKAGING_ARCH))
 				$(SUBDIRC++FLAGS) $(C++FLAGS) ;
 
-			C++ on $(header) = $(TARGET_C++) ;
+			C++ on $(header) = $(TARGET_C++_$(TARGET_PACKAGING_ARCH)) ;
 
-			includesSeparator = $(TARGET_INCLUDES_SEPARATOR) ;
+			includesSeparator
-			localIncludesOption = $(TARGET_LOCAL_INCLUDES_OPTION) ;
+				= $(TARGET_INCLUDES_SEPARATOR_$(TARGET_PACKAGING_ARCH)) ;
-			systemIncludesOption = $(TARGET_SYSTEM_INCLUDES_OPTION) ;
+			localIncludesOption
+				= $(TARGET_LOCAL_INCLUDES_OPTION_$(TARGET_PACKAGING_ARCH)) ;
+			systemIncludesOption
+				= $(TARGET_SYSTEM_INCLUDES_OPTION_$(TARGET_PACKAGING_ARCH)) ;
 		}
 	}
 
@@ -328,6 +333,7 @@ rule CreateAsmStructOffsetsHeader header : source
 	# for non-PODs. Since we're using the same compiler for the whole kernel and
 	# don't do virtual inheritence, that works well enough.
 	flags += -Wno-invalid-offsetof ;
+		# TODO: Rather get rid of the respective offsetof() instances.
 
 	# locate object, search for source, and set on target variables
 
@@ -376,8 +382,9 @@ rule MergeObjectFromObjects
 			LINK on $(1) = $(HOST_LD) ;
 			LINKFLAGS on $(target) = $(HOST_LDFLAGS) ;
 		} else {
-			LINK on $(1) = $(TARGET_LD) ;
+			LINK on $(1) = $(TARGET_LD_$(TARGET_PACKAGING_ARCH)) ;
-			LINKFLAGS on $(target) = $(TARGET_LDFLAGS) ;
+			LINKFLAGS on $(target)
+				= $(TARGET_LDFLAGS_$(TARGET_PACKAGING_ARCH)) ;
 		}
 	}
 
@@ -479,12 +486,12 @@ rule LinkAgainst
 
 	on $(target) {
 		# map libraries, if desired and target platform is Haiku
-		if $(PLATFORM) != host && $(mapLibs) = true
+		local map = $(TARGET_LIBRARY_NAME_MAP_$(TARGET_PACKAGING_ARCH)) ;
-				&& $(TARGET_LIBRARY_NAME_MAP) {
+		if $(PLATFORM) != host && $(mapLibs) = true && $(map) {
 			local mappedLibs ;
 
 			for i in $(libs) {
-				local mapped = $($(TARGET_LIBRARY_NAME_MAP)_$(i)) ;
+				local mapped = $($(map)_$(i)) ;
 				mapped ?= $(i) ;
 				mappedLibs += $(mapped) ;
 			}

build/jam/MiscRules

@@ -10,15 +10,21 @@ rule SetupObjectsDir
 	if $(relPath) = . {
 		relPath = ;
 	}
-	COMMON_PLATFORM_LOCATE_TARGET =
+
-		[ FDirName $(HAIKU_COMMON_PLATFORM_OBJECT_DIR) $(relPath) ] ;
+	COMMON_PLATFORM_LOCATE_TARGET
+		= [ FDirName $(HAIKU_COMMON_PLATFORM_OBJECT_DIR) $(relPath) ] ;
+	HOST_COMMON_ARCH_LOCATE_TARGET
+		= [ FDirName $(HOST_COMMON_ARCH_OBJECT_DIR) $(relPath) ] ;
+	TARGET_COMMON_ARCH_LOCATE_TARGET
+		= [ FDirName $(TARGET_COMMON_ARCH_OBJECT_DIR) $(relPath) ] ;
 
 	local var ;
-	for var in COMMON_ARCH COMMON_DEBUG DEBUG_$(HAIKU_DEBUG_LEVELS) {
+	for var in COMMON_DEBUG DEBUG_$(HAIKU_DEBUG_LEVELS) {
 		HOST_$(var)_LOCATE_TARGET
 			= [ FDirName $(HOST_$(var)_OBJECT_DIR) $(relPath) ] ;
 		TARGET_$(var)_LOCATE_TARGET
-			= [ FDirName $(TARGET_$(var)_OBJECT_DIR) $(relPath) ] ;
+			= [ FDirName $(TARGET_$(var)_OBJECT_DIR_$(TARGET_PACKAGING_ARCH))
+				$(relPath) ] ;
 	}
 
 	LOCATE_TARGET = $(COMMON_PLATFORM_LOCATE_TARGET) ;
@@ -71,58 +77,62 @@ rule SubIncludeGPL
 # pragma mark - MakeLocate variants
 
 
-rule MakeLocateCommonPlatform
+rule MakeLocateCommonPlatform files : subdir
 {
 	# The file is shared between all target platforms.
-	MakeLocate $(1) : $(COMMON_PLATFORM_LOCATE_TARGET) ;
+	MakeLocate $(files)
+		: [ FDirName $(COMMON_PLATFORM_LOCATE_TARGET) $(subdir) ] ;
 }
 
-rule MakeLocatePlatform
+rule MakeLocatePlatform files : subdir
 {
 	# The file is specific for the target platform, but
 	# architecture independent. Usually the right rule for generated
 	# sources, though sometimes sources can be architecture specific.
-	local files = $(1) ;
 	local file ;
 	for file in $(files) {
+		local directory ;
 		if [ on $(file) return $(PLATFORM) ] = host {
-			MakeLocate $(file) : $(HOST_COMMON_ARCH_LOCATE_TARGET) ;
+			directory = $(HOST_COMMON_ARCH_LOCATE_TARGET) ;
 		} else {
-			MakeLocate $(file) : $(TARGET_COMMON_ARCH_LOCATE_TARGET) ;
+			directory = $(TARGET_COMMON_ARCH_LOCATE_TARGET) ;
 		}
+		MakeLocate $(file) : [ FDirName $(directory) $(subdir) ] ;
 	}
 }
 
-rule MakeLocateArch
+rule MakeLocateArch files : subdir
 {
 	# The file is platform+architecture specific, but is debug
 	# level independent. This is usually the right rule for generated
 	# architecture specific data or source files.
-	local files = $(1) ;
 	local file ;
 	for file in $(files) {
+		local directory ;
 		if [ on $(file) return $(PLATFORM) ] = host {
-			MakeLocate $(file) : $(HOST_COMMON_DEBUG_LOCATE_TARGET) ;
+			directory = $(HOST_COMMON_DEBUG_LOCATE_TARGET) ;
 		} else {
-			MakeLocate $(file) : $(TARGET_COMMON_DEBUG_LOCATE_TARGET) ;
+			directory = $(TARGET_COMMON_DEBUG_LOCATE_TARGET) ;
 		}
+		MakeLocate $(file) : [ FDirName $(directory) $(subdir) ] ;
 	}
 }
 
-rule MakeLocateDebug
+rule MakeLocateDebug files : subdir
 {
 	# The file is platform+architecture+debug level specific.
 	# That's what should be used for compiled code.
-	local files = $(1) ;
 	local file ;
 	for file in $(files) {
+		local directory ;
 		on $(file) {
 			if $(PLATFORM) = host {
-				MakeLocate $(file) : $(HOST_DEBUG_$(DEBUG)_LOCATE_TARGET) ;
+				directory = $(HOST_DEBUG_$(DEBUG)_LOCATE_TARGET) ;
 			} else {
-				MakeLocate $(file) : $(TARGET_DEBUG_$(DEBUG)_LOCATE_TARGET) ;
+				directory = $(TARGET_DEBUG_$(DEBUG)_LOCATE_TARGET) ;
 			}
 		}
+		MakeLocate $(file) : [ FDirName $(directory) $(subdir) ] ;
 	}
 }
 
@@ -394,13 +404,31 @@ rule DefineBuildProfile name : type : path {
 		case "update" : {
 			JAM_TARGETS = $(buildTarget) ;
 			SetUpdateHaikuImageOnly 1 ;
+			HAIKU_PACKAGES_UPDATE_ONLY = 1 ;
 			HAIKU_INCLUDE_IN_IMAGE on $(HAIKU_BUILD_PROFILE_PARAMETERS) = 1 ;
+			HAIKU_INCLUDE_IN_PACKAGES on $(HAIKU_BUILD_PROFILE_PARAMETERS) = 1 ;
 		}
 
 		case "update-all" : {
 			JAM_TARGETS = $(buildTarget) ;
 			SetUpdateHaikuImageOnly 1 ;
+			HAIKU_PACKAGES_UPDATE_ONLY = 1 ;
 			HAIKU_INCLUDE_IN_IMAGE = 1 ;
+			HAIKU_INCLUDE_IN_PACKAGES = 1 ;
+		}
+
+		case "update-packages" : {
+			JAM_TARGETS = $(buildTarget) ;
+			SetUpdateHaikuImageOnly 1 ;
+			HAIKU_UPDATE_ALL_PACKAGES = 1 ;
+		}
+
+		case "build-package-list" : {
+			HAIKU_IMAGE_LIST_PACKAGES_TARGET
+				= $(HAIKU_BUILD_PROFILE_PARAMETERS[1]) ;
+			HAIKU_IMAGE_ADDITIONAL_PACKAGES
+				= $(HAIKU_BUILD_PROFILE_PARAMETERS[2-]) ;
+			JAM_TARGETS = $(HAIKU_IMAGE_LIST_PACKAGES_TARGET) ;
 		}
 
 		case "mount" : {
@@ -417,166 +445,3 @@ rule DefineBuildProfile name : type : path {
 
 	return 1 ;
 }
-
-
-# pragma mark - Build Features
-
-
-rule FIsBuildFeatureEnabled feature
-{
-	# FIsBuildFeatureEnabled <feature> ;
-	# Returns whether the given build feature <feature> is enabled (if so: "1",
-	# if not: empty list).
-	#
-	# <feature> - The name of the build feature (all lower case).
-
-	if $(feature) in $(HAIKU_BUILD_FEATURES) {
-		return 1 ;
-	}
-
-	return ;
-}
-
-
-rule FMatchesBuildFeatures specification
-{
-	# FMatchesBuildFeatures <specification> ;
-	# Returns whether the given build feature specification <specification>
-	# holds. <specification> consists of positive and negative build feature
-	# conditions. Conditions can be individual list elements and multiple
-	# conditions can be joined, separated by ",", in a single list element. The
-	# effect is the same; they are considered as single set of conditions.
-	# A positive condition does not start with a "!". It holds when the build
-	# feature named by the element is enabled.
-	# A negative condition starts with a "!". It holds when the build feature
-	# named by the string resulting from removing the leading "!" is not
-	# enabled.
-	# <specification> holds when it is not empty and
-	# * none of the negative conditions it contains hold and
-	# * if it contains any positive conditions, at least one one of them holds.
-	#
-	# <specification> - The build feature specification. A list of individual
-	#	conditions or conditions joined by ",".
-
-	local splitSpecification ;
-	local element ;
-	for element in $(specification) {
-		splitSpecification += [ FSplitString $(element) : "," ] ;
-	}
-	return [ FSetConditionsHold $(splitSpecification)
-		: $(HAIKU_BUILD_FEATURES) ] ;
-}
-
-
-rule FFilterByBuildFeatures list
-{
-	# FFilterByBuildFeatures <list> ;
-	# Filters the list annotated by build feature specifications and returns the
-	# resulting list. The list can be annotated in two different ways:
-	# * A single list element can be annotated by appending "@<specification>"
-	#   to it, with <specification> being a build feature specification (a
-	#   single comma-separated string). The element appears in the resulting
-	#   list, only if <specification> holds.
-	# * A sublist can be annotated by enclosing it in "<specification> @{" (two
-	#   separate list elements) and "}@", with <specification> being a build
-	#   feature specification (a single comma-separated string). The enclosed
-	#   sublist appears in the resulting list, only if <specification> holds.
-	# The sublist annotations can be nested. The annotations themselves don't
-	# appear in the resulting list.
-	#
-	# <list> - A list annotated with build feature specifications.
-
-	local filteredList ;
-
-	# Since we must look ahead one element to be able to decide whether an
-	# element is a regular list element or a features specification for a
-	# subsequent "@{". Hence we always process an element other than "@{" and
-	# "}@" in the next iteration. We append a dummy element to the list so we
-	# don't need special handling for the last element.
-	local evaluationStack = 1 ;
-	local previousElement ;
-	local element ;
-	for element in $(list) dummy {
-		local stackTop = $(evaluationStack[1]) ;
-		local processElement = $(previousElement) ;
-		switch $(element) {
-			case }@ :
-			{
-				# Pop the topmost specification off the stack.
-				evaluationStack = $(evaluationStack[2-]) ;
-				if ! $(evaluationStack) {
-					Exit "FFilterByBuildFeatures: Unbalanced @( in: " $(list) ;
-				}
-
-				processElement = $(previousElement) ;
-				previousElement = ;
-			}
-			case @{ :
-			{
-				if ! $(previousElement) {
-					Exit "FFilterByBuildFeatures: No feature specification"
-						"after )@ in: " $(list) ;
-				}
-
-				if $(evaluationStack[1]) = 1
-					&& [ FMatchesBuildFeatures $(previousElement) ] {
-					evaluationStack = 1 $(evaluationStack) ;
-				} else {
-					evaluationStack = 0 $(evaluationStack) ;
-				}
-
-				processElement = ;
-				previousElement = ;
-			}
-			case * :
-			{
-				processElement = $(previousElement) ;
-				previousElement = $(element) ;
-			}
-		}
-
-		if $(processElement) && $(stackTop) = 1 {
-			local splitElement = [ Match "(.*)@([^@]*)" : $(processElement) ] ;
-			if $(splitElement) {
-				if [ FMatchesBuildFeatures $(splitElement[2]) ] {
-					filteredList += $(splitElement[1]) ;
-				}
-			} else {
-				filteredList += $(processElement) ;
-			}
-		}
-	}
-
-	if $(evaluationStack[2-]) {
-		Exit "FFilterByBuildFeatures: Unbalanced )@ in: " $(list) ;
-	}
-
-	return $(filteredList) ;
-}
-
-
-rule EnableBuildFeatures features : specification
-{
-	# EnableBuildFeatures <features> : <specification> ;
-	# Enables the build features <features>, if the build features specification
-	# <specification> holds. If <specification> is omitted, the features are
-	# enabled unconditionally.
-	# The rule enables a build feature by adding its given lower case name to
-	# the build variable HAIKU_BUILD_FEATURES and defining a build variable
-	# HAIKU_BUILD_FEATURE_<FEATURE>_ENABLED (<FEATURE> being the upper case name
-	# of the build feature) to "1".
-	#
-	# <features> - A list of build feature names (lower case).
-	# <specification> - An optional build features specification (cf.
-	#	FMatchesBuildFeatures).
-
-	if ! $(specification)
-		|| [ FMatchesBuildFeatures $(specification)
-			: $(HAIKU_BUILD_FEATURES) ] {
-		local feature ;
-		for feature in $(features) {
-			HAIKU_BUILD_FEATURES += $(feature) ;
-			HAIKU_BUILD_FEATURE_$(feature:U)_ENABLED = 1 ;
-		}
-	}
-}

build/jam/OptionalLibPackages

@@ -1,356 +0,0 @@
-# This file defines the optional lib packages that can be added to the Haiku image.
-# It is directly included from HaikuImage -- all variables defined there can
-# be used
-
-# Detect a hybrid GCC2/GCC4 image and disable the checks for unavailable GCC4
-# packages. (It does not matter if a package was built with either compiler,
-# the system should have the respective other system libs.)
-local isHybridBuild ;
-if $(HAIKU_ADD_ALTERNATIVE_GCC_LIBS) = 1
-		&& $(HAIKU_ALTERNATIVE_GCC_OUTPUT_DIR) {
-	isHybridBuild = 1 ;
-}
-
-
-# Available Optional Lib Packages:
-#	AllegroLibs
-#	box2d
-#	fribidi
-#	lcms
-#	libart_lgpl
-#	libmad
-#	libmikmod
-#	libmodplug
-#	libpaper
-#	physfs
-#	SDLLibs
-#	XiphLibs
-
-
-local baseURL = http://haiku-files.org/files/optional-packages ;
-local baseSourceURL = http://haiku-files.org/files/sources ;
-
-
-# AllegroLibs
-if [ IsOptionalHaikuImagePackageAdded AllegroLibs ] {
-	# libsdl and related libs
-	if $(TARGET_ARCH) != x86 {
-		Echo "No optional package AllegroLibs available for $(TARGET_ARCH)" ;
-	} else if $(HAIKU_GCC_VERSION[1]) >= 4 {
-		InstallOptionalHaikuImagePackage
-			allegro-4.4.1.1-r1a4-x86-gcc4-2012-09-09.zip
-			: $(baseURL)/lib/allegro-4.4.1.1-r1a4-x86-gcc4-2012-09-09.zip ;
-		InstallOptionalHaikuImagePackage
-			dumb-0.9.3-r1a4-x86-gcc4-2012-09-09.zip
-			: $(baseURL)/lib/dumb-0.9.3-r1a4-x86-gcc4-2012-09-09.zip ;
-		InstallOptionalHaikuImagePackage
-			jgmod-0.99-r1a4-x86-gcc4-2012-09-09.zip
-			: $(baseURL)/lib/jgmod-0.99-r1a4-x86-gcc4-2012-09-09.zip ;
-	} else {
-		InstallOptionalHaikuImagePackage
-			allegro-4.4.1.1-r1a4-x86-gcc2-2012-08-30.zip
-			: $(baseURL)/lib/allegro-4.4.1.1-r1a4-x86-gcc2-2012-08-30.zip ;
-		InstallOptionalHaikuImagePackage
-			dumb-0.9.3-r1a4-x86-gcc2-2012-08-30.zip
-			: $(baseURL)/lib/dumb-0.9.3-r1a4-x86-gcc2-2012-08-30.zip ;
-		InstallOptionalHaikuImagePackage
-			jgmod-0.99-r1a4-x86-gcc2-2012-08-30.zip
-			: $(baseURL)/lib/jgmod-0.99-r1a4-x86-gcc2-2012-08-30.zip ;
-	}
-}
-
-
-# box2d
-if [ IsOptionalHaikuImagePackageAdded box2d ] {
-	if $(TARGET_ARCH) != x86 {
-		Echo "No optional package box2d available for $(TARGET_ARCH)" ;
-	} else {
-		if $(HAIKU_GCC_VERSION[1]) >= 4 || $(isHybridBuild) {
-			InstallOptionalHaikuImagePackage
-				box2d-2.1.2-r1a4-x86-gcc4-2012-09-09.zip
-				: $(baseURL)/lib/box2d-2.1.2-r1a4-x86-gcc4-2012-09-09.zip
-				: : true ;
-		} else {
-			Echo "No optional package box2d available for $(TARGET_ARCH)-gcc2" ;
-		}
-	}
-}
-
-
-# fribidi
-if [ IsOptionalHaikuImagePackageAdded fribidi ] {
-	if $(TARGET_ARCH) != x86 {
-		Echo "No optional package fribidi available for $(TARGET_ARCH)" ;
-	} else if $(HAIKU_GCC_VERSION[1]) >= 4 {
-		InstallOptionalHaikuImagePackage
-			fribidi-0.19.2-r1a4-x86-gcc4-2012-09-01.zip
-			: $(baseURL)/lib/fribidi-0.19.2-r1a4-x86-gcc4-2012-09-01.zip
-			: : true ;
-	} else {
-		InstallOptionalHaikuImagePackage
-			fribidi-0.19.2-r1a4-x86-gcc2-2012-08-29.zip
-			: $(baseURL)/lib/fribidi-0.19.2-r1a4-x86-gcc2-2012-08-29.zip
-			: : true ;
-	}
-}
-
-
-# lcms
-if [ IsOptionalHaikuImagePackageAdded lcms ] {
-	if $(TARGET_ARCH) != x86 {
-		Echo "No optional package lcms available for $(TARGET_ARCH)" ;
-	} else if $(HAIKU_GCC_VERSION[1]) >= 4 {
-		InstallOptionalHaikuImagePackage
-			lcms-2.1-r1a4-x86-gcc4-2012-09-02.zip
-			: $(baseURL)/lib/lcms-2.1-r1a4-x86-gcc4-2012-09-02.zip
-			: : true ;
-	} else {
-		InstallOptionalHaikuImagePackage
-			lcms-2.1-r1a4-x86-gcc2-2012-08-29.zip
-			: $(baseURL)/lib/lcms-2.1-r1a4-x86-gcc2-2012-08-29.zip
-			: : true ;
-	}
-}
-
-
-# libart_lgpl
-if [ IsOptionalHaikuImagePackageAdded libart_lgpl ] {
-	if $(TARGET_ARCH) != x86 {
-		Echo "No optional package libart_lgpl available for $(TARGET_ARCH)" ;
-	} else if $(HAIKU_GCC_VERSION[1]) >= 4 {
-		InstallOptionalHaikuImagePackage
-			libart_lgpl-2.3.21-r1a4-x86-gcc4-2012-09-02.zip
-			: $(baseURL)/lib/libart_lgpl-2.3.21-r1a4-x86-gcc4-2012-09-02.zip
-			: : true ;
-	} else {
-		InstallOptionalHaikuImagePackage
-			libart_lgpl-2.3.21-r1a4-x86-gcc2-2012-08-29.zip
-			: $(baseURL)/lib/libart_lgpl-2.3.21-r1a4-x86-gcc2-2012-08-29.zip
-			: : true ;
-	}
-}
-
-
-# libmad
-if [ IsOptionalHaikuImagePackageAdded libmad ] {
-	if $(TARGET_ARCH) != x86 {
-		Echo "No optional package libmad available for $(TARGET_ARCH)" ;
-	} else if $(HAIKU_GCC_VERSION[1]) >= 4 {
-		InstallOptionalHaikuImagePackage
-			libmad-0.15.1b-r1a4-x86-gcc4-2012-09-02.zip
-			: $(baseURL)/lib/libmad-0.15.1b-r1a4-x86-gcc4-2012-09-02.zip
-			: : true ;
-	} else {
-		InstallOptionalHaikuImagePackage
-			libmad-0.15.1b-r1a4-x86-gcc2-2012-08-29.zip
-			: $(baseURL)/lib/libmad-0.15.1b-r1a4-x86-gcc2-2012-08-29.zip
-			: : true ;
-	}
-}
-
-
-# libmikmod
-if [ IsOptionalHaikuImagePackageAdded libmikmod ] {
-	if $(TARGET_ARCH) != x86 {
-		Echo "No optional package libmikmod available for $(TARGET_ARCH)" ;
-	} else if $(HAIKU_GCC_VERSION[1]) >= 4 {
-		InstallOptionalHaikuImagePackage
-			libmikmod-3.1.11-r1a4-x86-gcc4-2012-09-02.zip
-			: $(baseURL)/lib/libmikmod-3.1.11-r1a4-x86-gcc4-2012-09-02.zip
-			: : true ;
-	} else {
-		InstallOptionalHaikuImagePackage
-			libmikmod-3.1.11-r1a4-x86-gcc2-2012-08-29.zip
-			: $(baseURL)/lib/libmikmod-3.1.11-r1a4-x86-gcc2-2012-08-29.zip
-			: : true ;
-	}
-}
-
-
-# libmodplug
-if [ IsOptionalHaikuImagePackageAdded libmodplug ] {
-	if $(TARGET_ARCH) != x86 {
-		Echo "No optional package libmodplug available for $(TARGET_ARCH)" ;
-	} else if $(HAIKU_GCC_VERSION[1]) >= 4 {
-		InstallOptionalHaikuImagePackage
-			libmodplug-0.8.8.4-r1a4-x86-gcc4-2012-09-02.zip
-			: $(baseURL)/lib/libmodplug-0.8.8.4-r1a4-x86-gcc4-2012-09-02.zip
-			: : true ;
-	} else {
-		InstallOptionalHaikuImagePackage
-			libmodplug-0.8.8.4-r1a4-x86-gcc2-2012-08-29.zip
-			: $(baseURL)/lib/libmodplug-0.8.8.4-r1a4-x86-gcc2-2012-08-29.zip
-			: : true ;
-	}
-}
-
-
-# libpaper
-if [ IsOptionalHaikuImagePackageAdded libpaper ] {
-	if $(TARGET_ARCH) != x86 {
-		Echo "No optional package libpaper available for $(TARGET_ARCH)" ;
-	} else if $(HAIKU_GCC_VERSION[1]) >= 4 {
-		InstallOptionalHaikuImagePackage
-			libpaper-1.1.24-r1a4-x86-gcc4-2012-09-01.zip
-			: $(baseURL)/lib/libpaper-1.1.24-r1a4-x86-gcc4-2012-09-01.zip
-			: : true ;
-	} else {
-		InstallOptionalHaikuImagePackage
-			libpaper-1.1.24-r1a4-x86-gcc4-2012-09-01.zip
-			: $(baseURL)/lib/libpaper-1.1.24-r1a4-x86-gcc4-2012-09-01.zip
-			: : true ;
-	}
-}
-
-
-# physfs
-if [ IsOptionalHaikuImagePackageAdded physfs ] {
-	if $(TARGET_ARCH) != x86 {
-		Echo "No optional package physfs available for $(TARGET_ARCH)" ;
-	} else if $(HAIKU_GCC_VERSION[1]) >= 4 {
-		InstallOptionalHaikuImagePackage
-			physfs-2.0.1-r1a4-x86-gcc4-2012-09-09.zip
-			: $(baseURL)/lib/physfs-2.0.1-r1a4-x86-gcc4-2012-09-09.zip
-			: : true ;
-	} else {
-		InstallOptionalHaikuImagePackage
-			physfs-2.0.1-r1a4-x86-gcc2-2012-08-29.zip
-			: $(baseURL)/lib/physfs-2.0.1-r1a4-x86-gcc2-2012-08-29.zip
-			: : true ;
-	}
-}
-
-
-# SDLLibs
-if [ IsOptionalHaikuImagePackageAdded SDLLibs ] {
-	if $(TARGET_ARCH) != x86 {
-		Echo "No optional package SDLLibs available for $(TARGET_ARCH)" ;
-	} else if $(HAIKU_GCC_VERSION[1]) >= 4 {
-		InstallOptionalHaikuImagePackage
-			libsdl-1.2.15-r1a4-x86-gcc4-2012-09-02.zip
-			: $(baseURL)/lib/libsdl-1.2.15-r1a4-x86-gcc4-2012-09-02.zip ;
-		InstallOptionalHaikuImagePackage
-			guilib-1.2.1-r1a4-x86-gcc4-2012-09-02.zip
-			: $(baseURL)/lib/guilib-1.2.1-r1a4-x86-gcc4-2012-09-02.zip ;
-		InstallOptionalHaikuImagePackage
-			sdl-gfx-2.0.23-r1a4-x86-gcc4-2012-09-02.zip
-			: $(baseURL)/lib/sdl-gfx-2.0.23-r1a4-x86-gcc4-2012-09-02.zip ;
-		InstallOptionalHaikuImagePackage
-			sdl-image-1.2.12-r1a4-x86-gcc4-2012-09-02.zip
-			: $(baseURL)/lib/sdl-image-1.2.12-r1a4-x86-gcc4-2012-09-02.zip ;
-		InstallOptionalHaikuImagePackage
-			sdl-mixer-1.2.11-r1a4-x86-gcc4-2012-09-02.zip
-			: $(baseURL)/lib/sdl-mixer-1.2.11-r1a4-x86-gcc4-2012-09-02.zip ;
-		InstallOptionalHaikuImagePackage
-			sdl-net-1.2.8-r1a4-x86-gcc4-2012-09-02.zip
-			: $(baseURL)/lib/sdl-net-1.2.8-r1a4-x86-gcc4-2012-09-02.zip ;
-		InstallOptionalHaikuImagePackage
-			sdl-sound-1.0.3-r1a4-x86-gcc4-2012-09-02.zip
-			: $(baseURL)/lib/sdl-sound-1.0.3-r1a4-x86-gcc4-2012-09-02.zip ;
-		InstallOptionalHaikuImagePackage
-			sdl-rtf-0.1.0-r1a4-x86-gcc4-2012-09-03.zip
-			: $(baseURL)/lib/sdl-rtf-0.1.0-r1a4-x86-gcc4-2012-09-03.zip ;
-		InstallOptionalHaikuImagePackage
-			sdl-ttf-2.0.11-r1a4-x86-gcc4-2012-09-02.zip
-			: $(baseURL)/lib/sdl-ttf-2.0.11-r1a4-x86-gcc4-2012-09-02.zip ;
-		InstallOptionalHaikuImagePackage
-			sge-030809-r1a4-x86-gcc4-2012-09-02.zip
-			: $(baseURL)/lib/sge-030809-r1a4-x86-gcc4-2012-09-02.zip ;
-		InstallOptionalHaikuImagePackage
-			smjpeg-0.2.1-r1a4-x86-gcc4-2012-09-02.zip
-			: $(baseURL)/lib/smjpeg-0.2.1-r1a4-x86-gcc4-2012-09-02.zip ;
-		InstallOptionalHaikuImagePackage
-			smpeg-0.4.5-r1a4-x86-gcc4-2012-09-02.zip
-			: $(baseURL)/lib/smpeg-0.4.5-r1a4-x86-gcc4-2012-09-02.zip ;
-	} else {
-		InstallOptionalHaikuImagePackage
-			libsdl-1.2.15-r1a4-x86-gcc2-2012-08-29.zip
-			: $(baseURL)/lib/libsdl-1.2.15-r1a4-x86-gcc2-2012-08-29.zip ;
-		InstallOptionalHaikuImagePackage
-			guilib-1.2.1-r1a4-x86-gcc2-2012-08-29.zip
-			: $(baseURL)/lib/guilib-1.2.1-r1a4-x86-gcc2-2012-08-29.zip ;
-		InstallOptionalHaikuImagePackage
-			sdl-gfx-2.0.23-r1a4-x86-gcc2-2012-08-29.zip
-			: $(baseURL)/lib/sdl-gfx-2.0.23-r1a4-x86-gcc2-2012-08-29.zip ;
-		InstallOptionalHaikuImagePackage
-			sdl-image-1.2.12-r1a4-x86-gcc2-2012-08-29.zip
-			: $(baseURL)/lib/sdl-image-1.2.12-r1a4-x86-gcc2-2012-08-29.zip ;
-		InstallOptionalHaikuImagePackage
-			sdl-mixer-1.2.11-r1a4-x86-gcc2-2012-08-29.zip
-			: $(baseURL)/lib/sdl-mixer-1.2.11-r1a4-x86-gcc2-2012-08-29.zip ;
-		InstallOptionalHaikuImagePackage
-			sdl-net-1.2.8-r1a4-x86-gcc2-2012-08-29.zip
-			: $(baseURL)/lib/sdl-net-1.2.8-r1a4-x86-gcc2-2012-08-29.zip ;
-		InstallOptionalHaikuImagePackage
-			sdl-sound-1.0-hg-r1a4-x86-gcc2-2012-08-30.zip
-			: $(baseURL)/lib/sdl-sound-1.0-hg-r1a4-x86-gcc2-2012-08-30.zip ;
-		InstallOptionalHaikuImagePackage
-			sdl-rtf-0.1.0-r1a3-x86-gcc2-2011-05-20.zip
-			: $(baseURL)/lib/sdl-rtf-0.1.0-r1a3-x86-gcc2-2011-05-20.zip ;
-		InstallOptionalHaikuImagePackage
-			sdl-ttf-2.0.11-r1a4-x86-gcc2-2012-08-29.zip
-			: $(baseURL)/lib/sdl-ttf-2.0.11-r1a4-x86-gcc2-2012-08-29.zip ;
-		InstallOptionalHaikuImagePackage
-			sge-030809-r1a4-x86-gcc2-2012-08-29.zip
-			: $(baseURL)/lib/sge-030809-r1a4-x86-gcc2-2012-08-29.zip ;
-		InstallOptionalHaikuImagePackage
-			smjpeg-0.2.1-r1a4-x86-gcc2-2012-08-29.zip
-			: $(baseURL)/lib/smjpeg-0.2.1-r1a4-x86-gcc2-2012-08-29.zip ;
-		InstallOptionalHaikuImagePackage
-			smpeg-0.4.5-r1a4-x86-gcc2-2012-08-29.zip
-			: $(baseURL)/lib/smpeg-0.4.5-r1a4-x86-gcc2-2012-08-29.zip ;
-	}
-}
-
-
-# XiphLibs
-if [ IsOptionalHaikuImagePackageAdded XiphLibs ] {
-	if $(TARGET_ARCH) != x86 {
-		Echo "No optional package XiphLibs available for $(TARGET_ARCH)" ;
-	} else if $(HAIKU_GCC_VERSION[1]) >= 4 {
-		InstallOptionalHaikuImagePackage
-			flac-1.2.1-r1a4-x86-gcc4-2012-09-02.zip
-			: $(baseURL)/lib/flac-1.2.1-r1a4-x86-gcc4-2012-09-02.zip ;
-		InstallOptionalHaikuImagePackage
-			libao-1.0.0-r1a4-x86-gcc4-2012-09-02.zip
-			: $(baseURL)/lib/libao-1.0.0-r1a4-x86-gcc4-2012-09-02.zip ;
-		InstallOptionalHaikuImagePackage
-			libogg-1.3.0-r1a4-x86-gcc4-2012-09-02.zip
-			: $(baseURL)/lib/libogg-1.3.0-r1a4-x86-gcc4-2012-09-02.zip ;
-		InstallOptionalHaikuImagePackage
-			libtheora-1.1.1-r1a4-x86-gcc4-2012-09-02.zip
-			: $(baseURL)/lib/libtheora-1.1.1-r1a4-x86-gcc4-2012-09-02.zip ;
-		InstallOptionalHaikuImagePackage
-			libvorbis-1.3.2-r1a4-x86-gcc4-2012-09-02.zip
-			: $(baseURL)/lib/libvorbis-1.3.2-r1a4-x86-gcc4-2012-09-02.zip ;
-		InstallOptionalHaikuImagePackage
-			speex-1.2rc1-r1a4-x86-gcc4-2012-09-02.zip
-			: $(baseURL)/lib/speex-1.2rc1-r1a4-x86-gcc4-2012-09-02.zip ;
-		InstallOptionalHaikuImagePackage
-			vorbis-tools-1.4.0-r1a4-x86-gcc4-2012-09-02.zip
-			: $(baseURL)/lib/vorbis-tools-1.4.0-r1a4-x86-gcc4-2012-09-02.zip ;
-	} else {
-		InstallOptionalHaikuImagePackage
-			flac-1.2.1-r1a4-x86-gcc2-2012-08-29.zip
-			: $(baseURL)/lib/flac-1.2.1-r1a4-x86-gcc2-2012-08-29.zip ;
-		InstallOptionalHaikuImagePackage
-			libao-1.0.0-r1a4-x86-gcc2-2012-08-29.zip
-			: $(baseURL)/lib/libao-1.0.0-r1a4-x86-gcc2-2012-08-29.zip ;
-		InstallOptionalHaikuImagePackage
-			libogg-1.3.0-r1a4-x86-gcc2-2012-08-29.zip
-			: $(baseURL)/lib/libogg-1.3.0-r1a4-x86-gcc2-2012-08-29.zip ;
-		InstallOptionalHaikuImagePackage
-			libtheora-1.1.1-r1a4-x86-gcc2-2012-08-29.zip
-			: $(baseURL)/lib/libtheora-1.1.1-r1a4-x86-gcc2-2012-08-29.zip ;
-		InstallOptionalHaikuImagePackage
-			libvorbis-1.3.2-r1a4-x86-gcc2-2012-08-29.zip
-			: $(baseURL)/lib/libvorbis-1.3.2-r1a4-x86-gcc2-2012-08-29.zip ;
-		InstallOptionalHaikuImagePackage
-			speex-1.2rc1-r1a4-x86-gcc2-2012-08-29.zip
-			: $(baseURL)/lib/speex-1.2rc1-r1a4-x86-gcc2-2012-08-29.zip ;
-		InstallOptionalHaikuImagePackage
-			vorbis-tools-1.4.0-r1a4-x86-gcc2-2012-08-29.zip
-			: $(baseURL)/lib/vorbis-tools-1.4.0-r1a4-x86-gcc2-2012-08-29.zip ;
-	}
-}
-

build/jam/OptionalPackageDependencies

@@ -1,44 +0,0 @@
-
-# package dependencies
-#
-# For transitive dependencies dependents should be listed before their
-# dependencies.
-
-OptionalPackageDependencies APR-util : APR Expat ;
-OptionalPackageDependencies AllegroLibs : XiphLibs ;
-OptionalPackageDependencies ArmyKnife : TagLib ;
-OptionalPackageDependencies Beam : LibIconv LibLayout OpenSSL PCRE ;
-OptionalPackageDependencies BeHappy : BeBook NetSurf ;
-OptionalPackageDependencies BurnItNow : CDRecord ;
-OptionalPackageDependencies Caya : Expat ;
-OptionalPackageDependencies CDRecord : GetText LibIconv ;
-OptionalPackageDependencies Curl : OpenSSL ;
-OptionalPackageDependencies DevelopmentBase : CDRecord DevelopmentMin Yasm ;
-OptionalPackageDependencies Development : DevelopmentBase Perl ;
-OptionalPackageDependencies DevelopmentPowerPC : DevelopmentMin ;
-OptionalPackageDependencies GetText : LibIconv ;
-OptionalPackageDependencies Git : Expat Curl OpenSSL LibIconv ;
-OptionalPackageDependencies GitDoc : Man Git ;
-OptionalPackageDependencies ICU-devel : DevelopmentBase ;
-OptionalPackageDependencies LibLayout : DevelopmentBase ;
-OptionalPackageDependencies LibXML2 : XZ-Utils ;
-OptionalPackageDependencies Man : Groff ;
-OptionalPackageDependencies Tar : LibIconv ;
-OptionalPackageDependencies Python : Bzip ;
-OptionalPackageDependencies Mercurial : Python ;
-OptionalPackageDependencies Neon : LibXML2 ;
-OptionalPackageDependencies NetFS : UserlandFS ;
-OptionalPackageDependencies NetSurf : OpenSSL Curl LibXML2 LibIconv Libmng ;
-OptionalPackageDependencies OpenSSH : OpenSSL ;
-OptionalPackageDependencies OpenSSL : CARootCertificates ;
-OptionalPackageDependencies Paladin : CCache Fastdep PCRE ;
-OptionalPackageDependencies Pe : PCRE ;
-OptionalPackageDependencies SDLLibs : XiphLibs libmad libmikmod Libmng libmodplug physfs ;
-OptionalPackageDependencies Subversion : APR-util Neon LibIconv LibXML2 OpenSSL SQLite ;
-OptionalPackageDependencies Transmission : LibEvent Curl OpenSSL LibIconv ;
-OptionalPackageDependencies Vim : GetText LibIconv ;
-OptionalPackageDependencies WebPositive : Curl LibXML2 SQLite WebKit WebPositiveBookmarks ;
-OptionalPackageDependencies wpa_supplicant : OpenSSL ;
-OptionalPackageDependencies XZ-Utils : Tar ;
-
-OptionalPackageDependencies MandatoryPackages : Bzip Ctags Grep ICU Sed Tar TermInfo ;

build/jam/OptionalTestPackages

@@ -7,34 +7,35 @@
 
 
 # libMicro
-if [ IsOptionalHaikuImagePackageAdded libMicro ] {
+# TODO: Make this an actual package!
-	# add scripts, tattle executable and README
+# if [ IsOptionalHaikuImagePackageAdded libMicro ] {
-	SEARCH on <libmicro>bench <libmicro>multiview <libmicro>README
+# 	# add scripts, tattle executable and README
-		= [ FDirName $(HAIKU_TOP) src tests system benchmarks libMicro ] ;
+# 	SEARCH on <libmicro>bench <libmicro>multiview <libmicro>README
-
+# 		= [ FDirName $(HAIKU_TOP) src tests system benchmarks libMicro ] ;
-	AddFilesToHaikuImage home benchmarks libmicro
+# 
-		: <libmicro>bench <libmicro>multiview <libmicro>README ;
+# 	AddFilesToHaikuImage home benchmarks libmicro
-	AddFilesToHaikuImage home benchmarks libmicro bin-BePC : tattle ;
+# 		: <libmicro>bench <libmicro>multiview <libmicro>README ;
-
+# 	AddFilesToHaikuImage home benchmarks libmicro bin-BePC : tattle ;
-	# add libmicro benchmarks
+# 
-	AddFilesToHaikuImage home benchmarks libmicro bin-BePC :
+# 	# add libmicro benchmarks
-		atomic <libmicro>bind cachetocache cascade_cond cascade_fcntl
+# 	AddFilesToHaikuImage home benchmarks libmicro bin-BePC :
-		cascade_flock cascade_lockf cascade_mutex chdir close close_tcp
+# 		atomic <libmicro>bind cachetocache cascade_cond cascade_fcntl
-		connection dup exec exec_bin exit exp fcntl fcntl_ndelay file_lock fork
+# 		cascade_flock cascade_lockf cascade_mutex chdir close close_tcp
-		getcontext getenv <libmicro>getpeername getpid getrusage getsockname
+# 		connection dup exec exec_bin exit exp fcntl fcntl_ndelay file_lock fork
-		gettimeofday isatty listen localtime_r <libmicro>log longjmp lrand48
+# 		getcontext getenv <libmicro>getpeername getpid getrusage getsockname
-		lseek malloc memcpy memmove memrand memset mktime mmap mprotect msync
+# 		gettimeofday isatty listen localtime_r <libmicro>log longjmp lrand48
-		munmap mutex nop <libmicro>open pipe poll pread pthread_create pwrite
+# 		lseek malloc memcpy memmove memrand memset mktime mmap mprotect msync
-		read realpath recurse select semop setcontext setsockopt sigaction
+# 		munmap mutex nop <libmicro>open pipe poll pread pthread_create pwrite
-		siglongjmp signal sigprocmask <libmicro>socket socketpair <libmicro>stat
+# 		read realpath recurse select semop setcontext setsockopt sigaction
-		strcasecmp strchr strcmp strcpy strftime strlen strtol system time times
+# 		siglongjmp signal sigprocmask <libmicro>socket socketpair <libmicro>stat
-		write writev ;
+# 		strcasecmp strchr strcmp strcpy strftime strlen strtol system time times
-
+# 		write writev ;
-	AddSymlinkToHaikuImage home benchmarks libmicro : bin-BePC : bin ;
+# 
-
+# 	AddSymlinkToHaikuImage home benchmarks libmicro : bin-BePC : bin ;
-	AddOptionalPackageDescriptionToHaikuImage
+# 
-		<libmicro>.OptionalPackageDescription
+# 	AddOptionalPackageDescriptionToHaikuImage
-		: $(HAIKU_TOP) src tests system benchmarks libMicro ;
+# 		<libmicro>.OptionalPackageDescription
-	AddLicenseToHaikuImage <libmicro>OPENSOLARIS.LICENSE : OpenSolaris
+# 		: $(HAIKU_TOP) src tests system benchmarks libMicro ;
-		: $(HAIKU_TOP) src tests system benchmarks libMicro ;
+# 	AddLicenseToHaikuImage <libmicro>OPENSOLARIS.LICENSE : OpenSolaris
-}
+# 		: $(HAIKU_TOP) src tests system benchmarks libMicro ;
+# }

build/jam/OverriddenJamRules

@@ -22,8 +22,8 @@ rule Link
 		LINK on $(1) = $(HOST_LINK) ;
 	 	LINKFLAGS on $(1) = $(HOST_LINKFLAGS) [ on $(1) return $(LINKFLAGS) ] ;
 	} else {
-		LINK on $(1) = $(TARGET_LINK) ;
+		LINK on $(1) = $(TARGET_LINK_$(TARGET_PACKAGING_ARCH)) ;
-	 	LINKFLAGS on $(1) = $(TARGET_LINKFLAGS)
+	 	LINKFLAGS on $(1) = $(TARGET_LINKFLAGS_$(TARGET_PACKAGING_ARCH))
 			[ on $(1) return $(LINKFLAGS) ] ;
 	}
 
@@ -34,9 +34,15 @@ rule Link
 	on $(1) XRes $(1) : $(RESFILES) ;
 	if ! [ on $(1) return $(DONT_USE_BEOS_RULES) ] {
 		SetType $(1) ;
-		MimeSet $(1) ;
+		MimeSet $(1) : sharedObject ;
 		SetVersion $(1) ;
 
+		# For applications for the target also generate the MIME DB entries.
+		if [ on $(1) return $(PLATFORM) ] != host
+			&& [ on $(1) return $(RESFILES) ] {
+			CreateAppMimeDBEntries $(1) ;
+		}
+
 		# If the generic attribute emulation is enabled, make sure the tool to
 		# remove the attributes is built first.
 		if $(HOST_RM_ATTRS_TARGET) {
@@ -100,8 +106,9 @@ rule Object
 			}
 
 		} else {
-			sysHeaders += $(TARGET_HDRS) ;
+			sysHeaders += $(TARGET_HDRS_$(TARGET_PACKAGING_ARCH)) ;
-			defines += $(TARGET_DEFINES) ;
+			defines += $(TARGET_DEFINES_$(TARGET_PACKAGING_ARCH))
+				$(TARGET_DEFINES) ;
 		}
 	}
 
@@ -188,13 +195,17 @@ rule As
 		systemIncludesOption = $(HOST_SYSTEM_INCLUDES_OPTION) ;
 
 	} else {
-		flags = [ on $(1) return $(TARGET_ASFLAGS) $(ASFLAGS) ] ;
+		flags = [ on $(1) return $(TARGET_ASFLAGS_$(architecture))
+			$(ASFLAGS) ] ;
 
-		CC on $(1) = $(TARGET_CC) ;
+		CC on $(1) = $(TARGET_CC_$(TARGET_PACKAGING_ARCH)) ;
 
-		includesSeparator = $(TARGET_INCLUDES_SEPARATOR) ;
+		includesSeparator
-		localIncludesOption = $(TARGET_LOCAL_INCLUDES_OPTION) ;
+			= $(TARGET_INCLUDES_SEPARATOR_$(TARGET_PACKAGING_ARCH)) ;
-		systemIncludesOption = $(TARGET_SYSTEM_INCLUDES_OPTION) ;
+		localIncludesOption
+			= $(TARGET_LOCAL_INCLUDES_OPTION_$(TARGET_PACKAGING_ARCH)) ;
+		systemIncludesOption
+			= $(TARGET_SYSTEM_INCLUDES_OPTION_$(TARGET_PACKAGING_ARCH)) ;
 	}
 
 	Depends $(<) : $(>) ;
@@ -288,18 +299,22 @@ rule Cc
 		} else {
 			# warning flags
 			if $(WARNINGS) != 0 {
-				flags += $(TARGET_WARNING_CCFLAGS) ;
+				flags += $(TARGET_WARNING_CCFLAGS_$(TARGET_PACKAGING_ARCH)) ;
 			}
 
 			# debug and other flags
-			flags += $(TARGET_CCFLAGS) $(TARGET_DEBUG_$(DEBUG)_CCFLAGS)
+			flags += $(TARGET_CCFLAGS_$(TARGET_PACKAGING_ARCH))
+				$(TARGET_DEBUG_$(DEBUG)_CCFLAGS_$(TARGET_PACKAGING_ARCH))
 				$(SUBDIRCCFLAGS) $(CCFLAGS) ;
 
-			CC on $(1) = $(TARGET_CC) ;
+			CC on $(1) = $(TARGET_CC_$(TARGET_PACKAGING_ARCH)) ;
 
-			includesSeparator = $(TARGET_INCLUDES_SEPARATOR) ;
+			includesSeparator
-			localIncludesOption = $(TARGET_LOCAL_INCLUDES_OPTION) ;
+				= $(TARGET_INCLUDES_SEPARATOR_$(TARGET_PACKAGING_ARCH)) ;
-			systemIncludesOption = $(TARGET_SYSTEM_INCLUDES_OPTION) ;
+			localIncludesOption
+				= $(TARGET_LOCAL_INCLUDES_OPTION_$(TARGET_PACKAGING_ARCH)) ;
+			systemIncludesOption
+				= $(TARGET_SYSTEM_INCLUDES_OPTION_$(TARGET_PACKAGING_ARCH)) ;
 		}
 
 		CCFLAGS on $(<) = $(flags) ;
@@ -355,18 +370,22 @@ rule C++
 		} else {
 			# warning flags
 			if $(WARNINGS) != 0 {
-				flags += $(TARGET_WARNING_C++FLAGS) ;
+				flags += $(TARGET_WARNING_C++FLAGS_$(TARGET_PACKAGING_ARCH)) ;
 			}
 
 			# debug and other flags
-			flags += $(TARGET_C++FLAGS) $(TARGET_DEBUG_$(DEBUG)_C++FLAGS)
+			flags += $(TARGET_C++FLAGS_$(TARGET_PACKAGING_ARCH))
+				$(TARGET_DEBUG_$(DEBUG)_C++FLAGS_$(TARGET_PACKAGING_ARCH))
 				$(SUBDIRC++FLAGS) $(C++FLAGS) ;
 
-			C++ on $(1) = $(TARGET_C++) ;
+			C++ on $(1) = $(TARGET_C++_$(TARGET_PACKAGING_ARCH)) ;
 
-			includesSeparator = $(TARGET_INCLUDES_SEPARATOR) ;
+			includesSeparator
-			localIncludesOption = $(TARGET_LOCAL_INCLUDES_OPTION) ;
+				= $(TARGET_INCLUDES_SEPARATOR_$(TARGET_PACKAGING_ARCH)) ;
-			systemIncludesOption = $(TARGET_SYSTEM_INCLUDES_OPTION) ;
+			localIncludesOption
+				= $(TARGET_LOCAL_INCLUDES_OPTION_$(TARGET_PACKAGING_ARCH)) ;
+			systemIncludesOption
+				= $(TARGET_SYSTEM_INCLUDES_OPTION_$(TARGET_PACKAGING_ARCH)) ;
 		}
 
 		C++FLAGS on $(<) = $(flags) ;
@@ -418,8 +437,9 @@ rule LibraryFromObjects
 			AR on $(_l) = $(HOST_AR) $(HOST_ARFLAGS) ;
 			RANLIB on $(_l) = $(HOST_RANLIB) ;
 		} else {
-			AR on $(_l) = $(TARGET_AR) $(TARGET_ARFLAGS) ;
+			AR on $(_l) = $(TARGET_AR_$(TARGET_PACKAGING_ARCH))
-			RANLIB on $(_l) = $(TARGET_RANLIB) ;
+				$(TARGET_ARFLAGS_$(TARGET_PACKAGING_ARCH)) ;
+			RANLIB on $(_l) = $(TARGET_RANLIB_$(TARGET_PACKAGING_ARCH)) ;
 		}
 
 		# library depends on its member objects
@@ -529,7 +549,8 @@ rule MainFromObjects
 }
 
 # Override Jam 2.5rc3 MakeLocate and MkDir to deal more intelligently
-# with grist set on the supplied directory name.
+# with grist set on the supplied directory name. Also do nothing for already
+# located files.
 rule MakeLocate
 {
 	local dir = $(2[1]) ;
@@ -539,9 +560,16 @@ rule MakeLocate
 		if ! $(dir:G) {
 			dir = $(dir:G=dir) ;
 		}
-	    LOCATE on $(1) += $(dir:G=) ;	# don't relocate once located
+
-	    Depends $(1) : $(dir) ;
+		local target ;
-	    MkDir $(dir) ;
+		for target in $(1) {
+			# don't relocate once located
+		    LOCATE on $(target) += $(dir:G=) ;
+			if [ on $(target) return $(LOCATE) ] = $(dir:G=) {
+			    Depends $(target) : $(dir) ;
+		    	MkDir $(dir) ;
+			}
+		}
 	}
 }
 
@@ -646,11 +674,13 @@ rule ObjectHdrs
 					[ FSysIncludes $(SYSHDRS)
 						: $(HOST_SYSTEM_INCLUDES_OPTION) ] ;
 			} else {
+				local architecture = $(TARGET_PACKAGING_ARCH) ;
 				fileHeaders =
-					[ FIncludes $(localHeaders) : $(TARGET_LOCAL_INCLUDES_OPTION) ]
+					[ FIncludes $(localHeaders)
-					$(TARGET_INCLUDES_SEPARATOR)
+						: $(TARGET_LOCAL_INCLUDES_OPTION_$(architecture)) ]
+					$(TARGET_INCLUDES_SEPARATOR_$(architecture))
 					[ FSysIncludes $(SYSHDRS)
-						: $(TARGET_SYSTEM_INCLUDES_OPTION) ] ;
+						: $(TARGET_SYSTEM_INCLUDES_OPTION_$(architecture)) ] ;
 			}
 
 			ASHDRS on $(file) = $(fileHeaders) ;
@@ -692,3 +722,9 @@ rule SubInclude
 	# restore SUBDIR_TOKENS
 	SUBDIR_TOKENS = $(oldSubDirTokens) ;
 }
+
+
+actions File
+{
+	$(CP) "$(>)" "$(<)"
+}

build/jam/PackageRules

@@ -1,250 +1,242 @@
-#-------------------------------------------------------------------------------
+rule FHaikuPackageGrist package
-# Packages for OBOS alpha/beta testers
-#-------------------------------------------------------------------------------
-
-rule Copy
 {
-	if $(2) {
+	local grist = [ Match "<(.*)>" : $(package:G) ] ;
-		SEARCH on $(2) += $(SEARCH_SOURCE) ;
+	return hpkg_$(grist:E="")-$(package:G=) ;
-		Depends $(1) : <build>copyattr $(2) ;
-		Copy1 $(1) : <build>copyattr $(2) ;
-	}
 }
 
-actions Copy1
+
+rule HaikuPackage package
 {
-	$(HOST_ADD_BUILD_COMPATIBILITY_LIB_DIR)
+	local grist = [ FHaikuPackageGrist $(package) ] ;
-	"$(2[1])" -d "$(2[2-])" "$(1)"
-}
 
-rule Packages
+	HAIKU_CONTAINER_GRIST on $(package) = $(grist) ;
-{
+	HAIKU_INCLUDE_IN_CONTAINER_VAR on $(package) = HAIKU_INCLUDE_IN_PACKAGES ;
-	local packagenames = $(1) ;
+	HAIKU_INSTALL_TARGETS_VAR on $(package)
-	local packagefiles = $(2) ;
+		= $(grist)_HAIKU_PACKAGE_INSTALL_TARGETS ;
-	local path = $(3) ;
+	HAIKU_CONTAINER_SYSTEM_DIR_TOKENS on $(package) = ;
-	for name in $(packagenames) {
-		Package $(name) : $(packagefiles) : $(path) ;
-    }
-}
 
-rule FPackageConfigSubPath
+	HAIKU_CURRENTLY_BUILT_HAIKU_PACKAGE = $(package) ;
-{
-	# FPackageConfigSubPath <packagename>
-	#
-	local packagename = $(1) ;
 
-	local configSubPath ;
+	if $(HAIKU_PACKAGES_UPDATE_ONLY) {
-	on $(packagename) {
+		HAIKU_CONTAINER_UPDATE_ONLY on $(package) = 1 ;
-		if $(PLATFORM) = host {
+		HAIKU_CONTAINER_INHERIT_UPDATE_VARIABLE on $(package)
-			configSubPath = $(HOST_PLATFORM) $(HOST_ARCH) ;
+			= HAIKU_INCLUDE_IN_IMAGE ;
-		} else {
+	} else if $(HAIKU_UPDATE_ALL_PACKAGES) {
-			configSubPath = $(TARGET_PLATFORM) $(TARGET_ARCH) ;
+		HAIKU_INCLUDE_IN_IMAGE on $(package) = 1 ;
-		}
-	
-		if $(DEBUG) = 0 {
-			configSubPath += release ;
-		} else {
-			configSubPath += debug_$(DEBUG) ;
-		}
 	}
 
-	return $(configSubPath) ;
+	HAIKU_CONTAINER_ALWAYS_CREATE_DIRECTORIES on $(package) = 1 ;
 }
 
-rule Package
+
+rule PreprocessPackageInfo source : directory : architecture
+	: secondaryArchitecture
 {
-	local packagename = $(1) ;
+	source = $(source:G=package-info-source) ;
-    local packagefiles = $(2) ;
+	SEARCH on $(source) +=
-	local path = $(3) ;
+		[ FDirName $(HAIKU_PACKAGE_INFOS_DIR) $(architecture) ]
+		[ FDirName $(HAIKU_PACKAGE_INFOS_DIR) any ]
+		[ FDirName $(HAIKU_PACKAGE_INFOS_DIR) generic ] 
+	;
 
-	local configSubPath = [ FPackageConfigSubPath $(packagename) ] ;
+	local target = $(source:BSG=package-info)-package-info ;
-	local packagezip = $(packagename:S=.zip:G=_packages) ;
+	local defines = HAIKU_PACKAGING_ARCH=$(architecture) ;
-	local targetDir = [ FDirName $(HAIKU_PACKAGE_DIR) $(configSubPath) ] ;
+	local sedReplacements = %HAIKU_PACKAGING_ARCH%,$(architecture) ;
-	local packagedir = [ FDirName $(targetDir) $(packagename) ] ;
+	if $(HAIKU_BOOTSTRAP_BUILD) {
-
+		defines += HAIKU_BOOTSTRAP_BUILD ;
-    local installscript = install.sh ;
+		target = $(target)-bootstrap ;
-	local packageinstallscript = $(installscript:G=_packages!$(packagename)) ;
-    local installzip = install.zip ;
-	local packageinstallzip = $(installzip:G=_packages!$(packagename)) ;
-
-    local packageobjectdir = [ FDirName $(HAIKU_PACKAGE_OBJECT_DIR)
-		$(configSubPath) $(packagename) ] ;
-	local packagefiledir =  [ FDirName $(packageobjectdir) $(path) ] ;
-    local packagefileinstallzip
-    	= $(installzip:G=_package_objects!$(packagename)) ;
-
-	# add the files to the install.zip
-	local packagefilegrist = [ FGrist _package_files $(packagename) $(path) ] ;
-    for file in $(packagefiles) {
-		if $(path[0]) = "boot" {
-			local packagefile = $(file:G=$(packagefilegrist)) ;
-			MakeLocate $(packagefile) : $(packagefiledir) ;
-			Copy $(packagefile) : $(file) ;
-			Clean cleanPackages : $(packagefile) ;
-			PackageInstallZip $(packagefileinstallzip) : $(packagefile) ;
-		} else {
-			local packagefile = $(file:G=_packages!$(packagename)) ;
-			MakeLocate $(packagefile) : $(packagedir) ;
-			Copy $(packagefile) : [ FGristFiles $(file) ] ;
-			Clean cleanPackages : $(packagefile) ;
-			Depends $(packagezip) : $(packagefile) ;
-		}
 	}
-
+	if $(secondaryArchitecture) {
-	# general setup for this package -- only on first invocation
+		defines += HAIKU_SECONDARY_PACKAGING_ARCH=$(secondaryArchitecture) ;
-	if ! $(_setup_$(packagename)) {
+		sedReplacements
-		_setup_$(packagename) = true ;
+			+= %HAIKU_SECONDARY_PACKAGING_ARCH%,$(secondaryArchitecture) ;
-
+		sedReplacements +=
-		NotFile $(packagename) ;
+			%HAIKU_SECONDARY_PACKAGING_ARCH_SUFFIX%,_$(secondaryArchitecture) ;
-		LocalDepends packages : $(packagename) ;
-
-		MakeLocate $(packagezip) : $(targetDir) ;
-		MakeLocate $(packageinstallscript) : $(packagedir) ;
-		MakeLocate $(packageinstallzip) : $(packagedir) ;
-		MakeLocate $(packagefileinstallzip) : $(packageobjectdir) ;
-
-		PackageInstallScript $(packageinstallscript) : $(packagedir) ;
-		LinkInstallZip $(packageinstallzip) : $(packagefileinstallzip) ;
-		Depends $(packagename) : $(packagezip) ;
-		PackageZip $(packagezip) : $(packagedir)
-			: $(packageinstallscript) $(packageinstallzip) ;
-	}
-
-}
-
-rule PackageSymLink
-{
-	# PackageSymLink <packageName> : <symlink path components>
-	#	: <symlink target>
-	#
-	local packagename = $(1) ;
-	local symlinkPath = $(2) ;
-	local symlinkTarget = $(3) ;
-	
-	local configSubPath = [ FPackageConfigSubPath $(packagename) ] ;
-
-	local symlinkDir = [ FReverse $(symlinkPath) ] ;
-	local symlink = $(symlinkDir[1]) ;
-	symlinkDir = [ FReverse $(symlinkDir[2-]) ] ;
-	local symlinkGrist = [ FGrist _package $(packagename) $(symlinkDir) ] ;
-	symlink = $(symlink:G=$(symlinkGrist)) ;
-
-	if $(symlinkDir[1]) = boot {
-	    local installzip = install.zip ;
-	    local packagefileinstallzip
-    		= $(installzip:G=_package_objects!$(packagename)) ;
-
-		local packageobjectdir = [ FDirName $(HAIKU_PACKAGE_OBJECT_DIR)
-			$(configSubPath) $(packagename) ] ;
-		symlinkDir = [ FDirName $(packageobjectdir) $(symlinkDir) ] ;
-
-		PackageInstallZip $(packagefileinstallzip) : $(symlink) ;
-
 	} else {
-		local packagezip = $(packagename:S=.zip:G=_packages) ;
+		sedReplacements
-
+			+= %HAIKU_SECONDARY_PACKAGING_ARCH_SUFFIX%, ;
-		local packagedir = [ FDirName $(HAIKU_PACKAGE_DIR) $(configSubPath)
-			$(packagename) ] ;
-		symlinkDir = [ FDirName $(packagedir) $(symlinkDir) ] ;
-
-		Depends $(packagezip) : $(symlink) ;
 	}
 
-	MakeLocate $(symlink) : $(symlinkDir) ;
+	MakeLocate $(target) : $(directory) ;
-	SymLink $(symlink) : $(symlinkTarget) : false ;
+	Depends $(target) : $(source) ;
-	Clean cleanPackages : $(symlink) ;
+
+	CCDEFS on $(target) = [ FDefines $(defines) ] ;
+	HAIKU_SED_REPLACEMENTS on $(target) = "-e s,$(sedReplacements),g" ;
+
+	PreprocessPackageInfo1 $(target) : $(source) ;
+
+	return $(target) ;
 }
 
-rule PackageDriverSymLink
+
+actions PreprocessPackageInfo1
 {
-	# PackageDriverSymLink <packageName> : <devRelativeSymlinkComponents> ;
+	sed $(HAIKU_SED_REPLACEMENTS) < $(2) | $(HOST_CC) -E -w $(CCDEFS) - -o $(1)
-	# <packageName>: Package name.
+}
-	# <devRelativeSymlinkComponents>: Path components relative to the 
-	#     /boot/home/config/add-ons/kernel/drivers/dev directory, e.g.
-	#     "graphics mga.driver" (no quotation, of course).
-	#
-	local packageName = $(1) ;
-	local symlinkComponents = $(2) ;
 
-	# construct the symlink contents
-	local symlinkPath = [ FReverse $(symlinkComponents) ] ;
-	symlinkPath = bin $(symlinkPath[1]) ;
 
-	for i in $(symlinkComponents) {
+rule BuildHaikuPackage package : packageInfo
-		symlinkPath = $(DOTDOT) $(symlinkPath) ;
+{
+	local architecture = $(HAIKU_PACKAGING_ARCH) ;
+	local secondaryArchitecture ;
+	if $(TARGET_PACKAGING_ARCH) != $(architecture) {
+		secondaryArchitecture = $(TARGET_PACKAGING_ARCH) ;
 	}
 
-	PackageSymLink $(packageName)
+	local grist = [ FHaikuPackageGrist $(package) ] ;
-		: boot home config add-ons kernel drivers dev $(symlinkComponents)
+
-		: [ FDirName $(symlinkPath) ] ;
+	local tempDir
+		= [ FDirName $(HAIKU_PACKAGES_BUILD_DIR_$(architecture)) $(grist) ] ;
+	local scriptDir = [ FDirName $(tempDir) scripts ] ;
+
+	#  build the package info and locate the package
+	packageInfo = [ PreprocessPackageInfo $(packageInfo) : $(tempDir)
+		: $(architecture) : $(secondaryArchitecture) ] ;
+	MakeLocate $(package) : $(HAIKU_PACKAGES_DIR_$(architecture)) ;
+	Depends $(package) : $(packageInfo) ;
+
+	# prepare the script that initializes the shell variables
+	local initVariablesScript = <$(grist)>haiku.package-init-vars ;
+	MakeLocate $(initVariablesScript) : $(scriptDir) ;
+	Always $(initVariablesScript) ;
+
+	local script = $(initVariablesScript) ;
+	AddVariableToScript $(script) : sourceDir : $(HAIKU_TOP) ;
+	AddVariableToScript $(script) : outputDir : $(HAIKU_OUTPUT_DIR) ;
+	AddVariableToScript $(script) : tmpDir : $(tempDir) ;
+	AddVariableToScript $(script) : addBuildCompatibilityLibDir
+		: $(HOST_ADD_BUILD_COMPATIBILITY_LIB_DIR) ;
+	AddVariableToScript $(script) : compressionLevel
+		: [ on $(package) return $(HAIKU_PACKAGE_COMPRESSION_LEVEL) ] ;
+	AddVariableToScript $(script) : updateOnly
+		: [ on $(package) return $(HAIKU_CONTAINER_UPDATE_ONLY) ] ;
+	AddVariableToScript $(script) : cc : $(TARGET_CC_$(architecture)) ;
+	AddTargetVariableToScript $(script) : <build>addattr ;
+	AddTargetVariableToScript $(script) : <build>copyattr ;
+	AddTargetVariableToScript $(script) : <mimedb>mime_db : mimeDB ;
+	AddTargetVariableToScript $(script) : <build>mimeset ;
+	AddTargetVariableToScript $(script) : <build>package ;
+	AddTargetVariableToScript $(script) : <build>rc ;
+	AddTargetVariableToScript $(script) : <build>resattr ;
+	AddTargetVariableToScript $(script) : <build>unzip ;
+	if $(HOST_RM_ATTRS_TARGET) {
+		AddTargetVariableToScript $(script) : $(HOST_RM_ATTRS_TARGET)
+			: rmAttrs ;
+	} else {
+		AddVariableToScript $(script) : rmAttrs : rm ;
+	}
+
+	# create the other scripts
+	local makeDirsScript = <$(grist)>haiku.package-make-dirs ;
+	local copyFilesScript = <$(grist)>haiku.package-copy-files ;
+	local extractFilesScript = <$(grist)>haiku.package-extract-files ;
+
+	MakeLocate $(makeDirsScript) $(copyFilesScript) $(extractFilesScript)
+		: $(scriptDir) ;
+
+	CreateContainerMakeDirectoriesScript $(package) : $(makeDirsScript) ;
+	CreateContainerCopyFilesScript $(package) : $(copyFilesScript) ;
+	CreateContainerExtractFilesScript $(package) : $(extractFilesScript) ;
+
+	local scripts = $(initVariablesScript) $(makeDirsScript)
+		$(copyFilesScript) $(extractFilesScript) ;
+
+	# call the build actions
+	local mainScript = build_haiku_package ;
+	SEARCH on $(mainScript) = [ FDirName $(HAIKU_TOP) build scripts ] ;
+
+	LocalDepends $(package) : $(mainScript) $(scripts) ;
+	BuildHaikuPackage1 $(package) : $(mainScript) $(packageInfo) $(scripts) ;
 }
 
-rule PackageZip
+
+actions BuildHaikuPackage1
 {
-	local dir = $(2:G=dir) ;
+	$(2[1]) "$(1)" "$(2[2])" $(2[3-])
-	Depends $(1) : $(dir) $(3) ;
-	Clean cleanPackages : $(1) ;
-	PackageZip1 $(1) : $(dir) ;
 }
 
-actions together PackageZip1 {
-	cd "$(2:P)" ;
-	zip -rq "$(1:BS)" "$(2:BS)" ;
-}
 
-rule PackageInstallScript
+rule AddDirectoryToPackage directoryTokens : attributeFiles
 {
-	MakeLocate $(1) : $(2) ;
+	return [ AddDirectoryToContainer $(HAIKU_CURRENTLY_BUILT_HAIKU_PACKAGE)
-	Clean cleanPackages : $(1) ;
+		: $(directoryTokens) : $(attributeFiles) ] ;
-	PackageInstallScript1 $(1) : $(2:G=dir) ;
 }
 
-actions together PackageInstallScript1
+
+rule AddFilesToPackage directory : targets : destName
 {
-echo '#!/bin/sh
+	AddFilesToContainer $(HAIKU_CURRENTLY_BUILT_HAIKU_PACKAGE) : $(directory)
-base=`dirname "$0"`
+		: $(targets) : $(destName) ;
-cd "$base"
-if [ -n "$TTY" ]
-then
-    unzip -d / install.zip
-else
-    response=`alert "Would you like to automatically overwrite existing files, or receive a prompt?" "Overwrite" "Prompt"`
-    if [ $response == "Overwrite" ]
-    then
-        unzip -od / install.zip
-        alert "Finished installing" "Thanks"
-    else
-        if [ -e /boot/beos/apps/Terminal ]
-        then
-            terminal=/boot/beos/apps/Terminal
-        else
-            terminal=`query Terminal | head -1`
-        fi
-        $terminal -t "installer" /bin/sh "$0"
-    fi
-fi' > "$(1)" ;
-	chmod 755 "$(1)" ;
 }
 
-rule PackageInstallZip
+
+rule AddSymlinkToPackage directoryTokens : linkTarget : linkName
 {
-	Depends $(1) : $(2) ;
+	linkTarget = $(linkTarget:J=/) ;
-	Clean cleanPackages : $(1) ;
+
+	AddSymlinkToContainer $(HAIKU_CURRENTLY_BUILT_HAIKU_PACKAGE)
+		: $(directoryTokens) : $(linkTarget) : $(linkName) ;
 }
 
-actions together PackageInstallZip
+
+rule CopyDirectoryToPackage directoryTokens : sourceDirectory
+	: targetDirectoryName : excludePatterns : flags
 {
-	cd "$(1:P)" ;
+	CopyDirectoryToContainer $(HAIKU_CURRENTLY_BUILT_HAIKU_PACKAGE)
-	zip -rqy "$(1:BS)" boot ;
+		: $(directoryTokens) : $(sourceDirectory) : $(targetDirectoryName)
+		: $(excludePatterns) : $(flags) ;
 }
 
-rule LinkInstallZip
+
+rule AddHeaderDirectoryToPackage dirTokens : dirName : flags
 {
-	Depends $(1) : $(2) ;
+	AddHeaderDirectoryToContainer $(HAIKU_CURRENTLY_BUILT_HAIKU_PACKAGE)
-	Clean cleanPackages : $(1) ;
+		: $(dirTokens) : $(dirName) : $(flags) ;
 }
 
-actions together LinkInstallZip
+
+rule AddWifiFirmwareToPackage driver : subDirToExtract : archive
+	: extract
 {
-	ln -sf "`pwd`/$(2)" "$(1)" ;
+	AddWifiFirmwareToContainer $(HAIKU_CURRENTLY_BUILT_HAIKU_PACKAGE)
+		: $(driver) : $(subDirToExtract) : $(archive) : $(extract) ;
 }
+
+
+rule ExtractArchiveToPackage dirTokens : archiveFile : flags : extractedSubDir
+{
+	ExtractArchiveToContainer $(HAIKU_CURRENTLY_BUILT_HAIKU_PACKAGE)
+		: $(dirTokens) : $(archiveFile) : $(flags) : $(extractedSubDir) ;
+}
+
+
+rule AddDriversToPackage relativeDirectoryTokens : targets
+{
+	AddDriversToContainer $(HAIKU_CURRENTLY_BUILT_HAIKU_PACKAGE)
+		: $(relativeDirectoryTokens) : $(targets) ;
+}
+
+
+rule AddNewDriversToPackage relativeDirectoryTokens : targets
+{
+	AddNewDriversToContainer $(HAIKU_CURRENTLY_BUILT_HAIKU_PACKAGE)
+		: $(relativeDirectoryTokens) : $(targets) ;
+}
+
+
+rule AddBootModuleSymlinksToPackage targets
+{
+	AddBootModuleSymlinksToContainer $(HAIKU_CURRENTLY_BUILT_HAIKU_PACKAGE)
+		: $(targets) ;
+}
+
+
+rule AddLibrariesToPackage directory : libs
+{
+	AddLibrariesToContainer $(HAIKU_CURRENTLY_BUILT_HAIKU_PACKAGE)
+		: $(directory) : $(libs) ;
+}
+
+
+# default value for the package compression level
+HAIKU_PACKAGE_COMPRESSION_LEVEL ?= 9 ;

build/jam/ReleaseBuildProfiles

@@ -1,55 +0,0 @@
-DefineBuildProfile alpha-raw : image : "haiku-alpha.image" ;
-DefineBuildProfile alpha-vmware : vmware-image : "haiku-alpha.vmdk" ;
-DefineBuildProfile alpha-cd : cd-image : "haiku-alpha.iso" ;
-DefineBuildProfile alpha-anyboot : anyboot-image
-	: "haiku-alpha-anyboot.image" ;
-DefineBuildProfile nightly-raw : image : "haiku-nightly.image" ;
-DefineBuildProfile nightly-vmware : vmware-image : "haiku-nightly.vmdk" ;
-DefineBuildProfile nightly-cd : cd-image : "haiku-nightly.iso" ;
-DefineBuildProfile nightly-anyboot : anyboot-image
-	: "haiku-nightly-anyboot.image" ;
-
-switch $(HAIKU_BUILD_PROFILE) {
-	case "alpha-*" : {
-		Echo Building Haiku R1/alpha ;
-		HAIKU_ROOT_USER_NAME = user ;
-		HAIKU_ROOT_USER_REAL_NAME = "Yourself" ;
-		AddGroupToHaikuImage party : 101 : user sshd ;
-		HAIKU_IMAGE_HOST_NAME = shredder ;
-		HAIKU_STRIP_DEBUG_FROM_OPTIONAL_PACKAGES = 1 ;
-		HAIKU_IMAGE_SIZE = 800 ;
-
-		AddOptionalHaikuImagePackages TimGMSoundFont TrackerNewTemplates
-			WQY-MicroHei ;
-		AddOptionalHaikuImagePackages BePDF Pe Vision
-			WebPositive WonderBrush ;
-		AddOptionalHaikuImagePackages CVS Development Git Mercurial
-			Python Subversion OpenSSH OpenSSL ;
-		AddOptionalHaikuImagePackages KeymapSwitcher Nano P7zip Welcome
-			BeBook XZ-Utils ;
-		AddOptionalHaikuImagePackages wpa_supplicant ;
-	}
-
-	case "beta-*" : {
-		Echo You wish. ;
-	}
-
-	case "nightly-*" : {
-		Echo Building Haiku Nightly ;
-		HAIKU_ROOT_USER_NAME = user ;
-		HAIKU_ROOT_USER_REAL_NAME = "Yourself" ;
-		AddGroupToHaikuImage party : 101 : user sshd ;
-		HAIKU_STRIP_DEBUG_FROM_OPTIONAL_PACKAGES = 1 ;
-		HAIKU_IMAGE_HOST_NAME = shredder ;
-		HAIKU_IMAGE_SIZE = 600 ;
-
-		AddOptionalHaikuImagePackages Pe Nano Vision P7zip XZ-Utils ;
-		AddOptionalHaikuImagePackages Development Git OpenSSH OpenSSL ;
-		AddOptionalHaikuImagePackages wpa_supplicant WebPositive ;
-	}
-}
-
-
-# Uncomment in official release branch.
-#HAIKU_DEFINES += HAIKU_OFFICIAL_RELEASE ;
-#TARGET_DEFINES += HAIKU_OFFICIAL_RELEASE ;

build/jam/RepositoryRules

@@ -0,0 +1,656 @@
+#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@_[^_]*$@@'`
+			;;
+		*_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 <[email protected]>"
+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 <[email protected]>"
+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
+{
+	[email protected]
+	
+	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"
+}

build/jam/UserBuildConfig.ReadMe

@@ -20,7 +20,7 @@ Exit You must NOT copy UserBuildConfig.ReadMe directly but use parts of it! ;
 #	CCFLAGS C++FLAGS DEBUG DEFINES HDRS LINKFLAGS OPTIM OPTIMIZE SYSHDRS
 #	WARNINGS
 #	HOST_WARNING_CCFLAGS HOST_WARNING_C++FLAGS
-#	TARGET_WARNING_CCFLAGS TARGET_WARNING_C++FLAGS
+#	TARGET_WARNING_CCFLAGS_<packageArch> TARGET_WARNING_C++FLAGS_<packageArch>
 #	PLATFORM SUPPORTED_PLATFORMS
 #
 # The following examples would work analogously for any of these variables.
@@ -62,10 +62,6 @@ HAIKU_IMAGE_NAME	= walter.image ;
 HAIKU_IMAGE_DIR		= /tmp ;
 HAIKU_IMAGE_SIZE	= 100 ;
 
-# Enable stripping the debug symbols from optional packages.
-# Note, some optional packages may override this to prevent stripping.
-HAIKU_STRIP_DEBUG_FROM_OPTIONAL_PACKAGES = 1 ;
-
 # Set image volume label to "Walter". Default label is "Haiku".
 HAIKU_IMAGE_LABEL	= Walter ;
 
@@ -79,6 +75,18 @@ HAIKU_INSTALL_DIR = /Haiku ;
 # freshly be initialized with BFS. Useful when installing Haiku on a partition.
 HAIKU_DONT_CLEAR_IMAGE = 1 ;
 
+# Set the compression level for the creation and update of Haiku packages to 1.
+# Values from 0 to 9 are supported. 0 means no compression, 1 fastest, ..., and
+# 9 best. The default is 9 which should be used for official builds (release or
+# nightly) to achieve the smallest possible package files at the cost of long
+# package building times. For developers who frequently rebuild/update packages
+# level 1 is a good compromise. Depending on the package data it's about an
+# order of magnitude faster while still achieving acceptable compression ratios.
+# Using level 0 will make package creation mostly I/O bound. It can be used, if
+# package size is not a concern. Depending on the package data, files may be
+# several times larger than even with level 1.
+HAIKU_PACKAGE_COMPRESSION_LEVEL = 1 ;
+
 
 # Affects the haiku-image, haiku-vmware-image, and install-haiku targets. Only
 # targets on which the HAIKU_INCLUDE_IN_IMAGE variable has been set will be
@@ -109,7 +117,7 @@ AddFilesToHaikuImage home config settings : <keymap>US-International : Key_map ;
 # Note that the second directory will also be copied, if the image will only
 # be updated; the first one won't in that case.
 AddSourceDirectoryToHaikuImage src/kits/storage ;
-AddSourceDirectoryToHaikuImage src/tests/servers/debug : 1 ;
+AddSourceDirectoryToHaikuImage src/tests/servers/debug : alwaysUpdate ;
 
 # Copy the jam sources (assuming they are located ../buildtools/jam relatively
 # to your Haiku sources) to the image as /boot/home/Desktop/jam-src, excluding
@@ -138,14 +146,6 @@ AddOptionalHaikuImagePackages WonderBrush ;
 AddOptionalHaikuImagePackages WebPositive ;
 SuppressOptionalHaikuImagePackages SQLite ;
 
-# Don't add the libraries built with the alternative gcc version.
-# If the alternative gcc generated directory has been specified via the
-# configure option --alternative-gcc-output-dir, the libraries for the
-# alternative gcc version are added by default. Unsetting this variable disables
-# building and adding the libraries. Ignored, if --alternative-gcc-output-dir
-# was not specified.
-HAIKU_ADD_ALTERNATIVE_GCC_LIBS = 0 ;
-
 # Specify scripts that shall be run when populating the image/installation
 # directory. The "early" script is run before anything has been copied onto
 # the image/into the installation directory. The "late" script is run after

build/jam/UserBuildConfig.sample

@@ -28,9 +28,6 @@
 # Add the optional package WonderBrush to the image.
 #AddOptionalHaikuImagePackages WonderBrush ;
 
-# Don't add the libraries built with the alternative gcc version.
-#HAIKU_ADD_ALTERNATIVE_GCC_LIBS = 0 ;
-
 # Add an example optional gfx driver and its accelerant.
 # (Drivers just have a special rule because of the need for the symlink in dev/)
 #AddDriversToHaikuImage graphics : optional_driver ;

build/jam/board/beagle/BoardSetup

@@ -64,7 +64,7 @@ HAIKU_BOARD_SDIMAGE_FILES =
 
 HAIKU_KERNEL_CCFLAGS += -mcpu=cortex-a8 -mfpu=vfp -mfloat-abi=soft ;
 HAIKU_KERNEL_C++FLAGS += -mcpu=cortex-a8 -mfpu=vfp -mfloat-abi=soft ;
-HAIKU_CCFLAGS += -mcpu=cortex-a8 -mfpu=vfp -mfloat-abi=soft ;
+HAIKU_CCFLAGS_$(HAIKU_PACKAGING_ARCH)
-HAIKU_C++FLAGS += -mcpu=cortex-a8 -mfpu=vfp -mfloat-abi=soft ;
+	+= -mcpu=cortex-a8 -mfpu=vfp -mfloat-abi=soft ;
-
+HAIKU_C++FLAGS_$(HAIKU_PACKAGING_ARCH)
-
+	+= -mcpu=cortex-a8 -mfpu=vfp -mfloat-abi=soft ;

build/jam/board/neo_freerunner/BoardSetup

@@ -71,15 +71,15 @@ HAIKU_BOARD_SDIMAGE_FILES =
 
 HAIKU_KERNEL_CCFLAGS += -mcpu=arm920t ;
 HAIKU_KERNEL_C++FLAGS += -mcpu=arm920t ;
-HAIKU_CCFLAGS += -mcpu=arm920t ;
+HAIKU_CCFLAGS_$(HAIKU_PACKAGING_ARCH) += -mcpu=arm920t ;
-HAIKU_C++FLAGS += -mcpu=arm920t ;
+HAIKU_C++FLAGS_$(HAIKU_PACKAGING_ARCH) += -mcpu=arm920t ;
 
 # Workaround for ld using 32k for alignment despite forcing it in the config...
 # should definitely not be needed!
 HAIKU_KERNEL_LINKFLAGS +=
 	-Wl,-z -Wl,max-page-size=0x1000
 	-Wl,-z -Wl,common-page-size=0x1000 ;
-HAIKU_LINKFLAGS +=
+HAIKU_LINKFLAGS_$(HAIKU_PACKAGING_ARCH) +=
 	-Wl,-z -Wl,max-page-size=0x1000
 	-Wl,-z -Wl,common-page-size=0x1000 ;
 

build/jam/board/overo/BoardSetup

@@ -60,7 +60,7 @@ HAIKU_BOARD_SDIMAGE_FILES =
 
 HAIKU_KERNEL_CCFLAGS += -mcpu=cortex-a8 -mfpu=vfp -mfloat-abi=soft ;
 HAIKU_KERNEL_C++FLAGS += -mcpu=cortex-a8 -mfpu=vfp -mfloat-abi=soft ;
-HAIKU_CCFLAGS += -mcpu=cortex-a8 -mfpu=vfp -mfloat-abi=soft ;
+HAIKU_CCFLAGS_$(HAIKU_PACKAGING_ARCH)
-HAIKU_C++FLAGS += -mcpu=cortex-a8 -mfpu=vfp -mfloat-abi=soft ;
+	+= -mcpu=cortex-a8 -mfpu=vfp -mfloat-abi=soft ;
-
+HAIKU_C++FLAGS_$(HAIKU_PACKAGING_ARCH)
-
+	+= -mcpu=cortex-a8 -mfpu=vfp -mfloat-abi=soft ;

build/jam/board/raspberry_pi/BoardSetup

@@ -48,15 +48,15 @@ HAIKU_BOARD_SDIMAGE_SIZE = 256 ;
 
 HAIKU_KERNEL_CCFLAGS += -mtune=arm1176jzf-s ;
 HAIKU_KERNEL_C++FLAGS += -mtune=arm1176jzf-s ;
-HAIKU_CCFLAGS += -mtune=arm1176jzf-s ;
+HAIKU_CCFLAGS_$(HAIKU_PACKAGING_ARCH) += -mtune=arm1176jzf-s ;
-HAIKU_C++FLAGS += -mtune=arm1176jzf-s ;
+HAIKU_C++FLAGS_$(HAIKU_PACKAGING_ARCH) += -mtune=arm1176jzf-s ;
 
 # Workaround for ld using 32k for alignment despite forcing it in the config...
 # should definitely not be needed!
 HAIKU_KERNEL_LINKFLAGS +=
 	-Wl,-z -Wl,max-page-size=0x1000
 	-Wl,-z -Wl,common-page-size=0x1000 ;
-HAIKU_LINKFLAGS +=
+HAIKU_LINKFLAGS_$(HAIKU_PACKAGING_ARCH) +=
 	-Wl,-z -Wl,max-page-size=0x1000
 	-Wl,-z -Wl,common-page-size=0x1000 ;
 

build/jam/board/verdex/BoardSetup

@@ -79,7 +79,6 @@ TARGET_ASFLAGS += -mcpu=xscale -D__XSCALE__ ;
 HAIKU_KERNEL_LINKFLAGS +=
 	-Wl,-z -Wl,max-page-size=0x1000
 	-Wl,-z -Wl,common-page-size=0x1000 ;
-HAIKU_LINKFLAGS +=
+HAIKU_LINKFLAGS_$(HAIKU_PACKAGING_ARCH) +=
 	-Wl,-z -Wl,max-page-size=0x1000
 	-Wl,-z -Wl,common-page-size=0x1000 ;
-

build/jam/images/FloppyBootImage

@@ -29,7 +29,9 @@ SYSTEM_ADD_ONS_BUS_MANAGERS = [ FFilterByBuildFeatures
 	acpi@x86 ata@ata config_manager dpc pci
 	ide@ide isa@x86 scsi $(USB_ONLY)usb
 ] ;
-SYSTEM_ADD_ONS_FILE_SYSTEMS = bfs iso9660 attribute_overlay write_overlay ;
+SYSTEM_ADD_ONS_FILE_SYSTEMS =
+	attribute_overlay bfs iso9660 packagefs write_overlay
+	;
 
 
 if $(TARGET_ARCH) = x86_64 {
@@ -106,7 +108,8 @@ if $(TARGET_ARCH) = x86_64 {
 }
 
 # kernel
-AddFilesToFloppyBootArchive system : <revisioned>kernel_$(TARGET_ARCH) ;
+AddFilesToFloppyBootArchive system
+	: <revisioned>kernel_$(TARGET_ARCH) ;
 
 # scripts and data files
 
@@ -120,13 +123,17 @@ if $(NET_BOOT) = 1 {
 	# add-ons
 	AddFilesToFloppyBootArchive system add-ons kernel network
 		: stack socket ;
-	AddFilesToFloppyBootArchive system add-ons kernel network devices
+	AddFilesToFloppyBootArchive
+		system add-ons kernel network devices
 		: $(SYSTEM_NETWORK_DEVICES) ;
-	AddFilesToFloppyBootArchive system add-ons kernel network datalink_protocols
+	AddFilesToFloppyBootArchive
+		system add-ons kernel network datalink_protocols
 		: $(SYSTEM_NETWORK_DATALINK_PROTOCOLS) ;
-	AddFilesToFloppyBootArchive system add-ons kernel network ppp
+	AddFilesToFloppyBootArchive
+		system add-ons kernel network ppp
 		: $(SYSTEM_NETWORK_PPP) ;
-	AddFilesToFloppyBootArchive system add-ons kernel network protocols
+	AddFilesToFloppyBootArchive
+		system add-ons kernel network protocols
 		: $(SYSTEM_NETWORK_PROTOCOLS) ;
 }
 

build/jam/images/HaikuCD

@@ -8,13 +8,6 @@ HAIKU_CD = $(HAIKU_CD_NAME) ;
 HAIKU_CD_LABEL ?= $(HAIKU_DEFAULT_CD_LABEL) ;
 MakeLocate $(HAIKU_CD) : $(HAIKU_CD_DIR) ;
 
-# Detect a hybrid GCC2/GCC4 image.
-local isHybridBuild ;
-if $(HAIKU_ADD_ALTERNATIVE_GCC_LIBS) = 1
-		&& $(HAIKU_ALTERNATIVE_GCC_OUTPUT_DIR) {
-	isHybridBuild = 1 ;
-}
-
 # prepare the script that initializes the shell variables
 HAIKU_CD_INIT_VARIABLES_SCRIPT = <HaikuCD>haiku.cd-init-vars ;
 local script = $(HAIKU_CD_INIT_VARIABLES_SCRIPT) ;
@@ -34,16 +27,14 @@ AddTargetVariableToScript $(script) : <build>rc ;
 AddTargetVariableToScript $(script) : <build>resattr ;
 AddTargetVariableToScript $(script) : <build>unzip ;
 AddTargetVariableToScript $(script) : <build>generate_attribute_stores ;
-AddVariableToScript $(script) : stripCommand : $(HAIKU_STRIP) ;
 if $(HOST_RM_ATTRS_TARGET) {
 	AddTargetVariableToScript $(script) : $(HOST_RM_ATTRS_TARGET) : rmAttrs ;
 } else {
 	AddVariableToScript $(script) : rmAttrs : rm ;
 }
-if $(optionalPackageDescriptions) {
+
-	AddTargetVariableToScript $(script) : $(optionalPackageDescriptions)
+AddPackagesAndRepositoryVariablesToContainerScript $(script)
-		: optionalPackageDescriptions ;
+	: $(HAIKU_IMAGE_CONTAINER_NAME) ;
-}
 
 # Convenience wrapper rule around BuildHaikuCD.
 rule _BuildHaikuCD haikuCD : bootFloppy

build/jam/images/HaikuImage

@@ -0,0 +1,341 @@
+# This file defines what ends up on the Haiku image (respectively in the Haiku
+# installation directory) and it executes the rules building the image
+# (respectively installing the files in the installation directory).
+
+
+SYSTEM_BIN = [ FFilterByBuildFeatures
+	"["
+	addattr alert arp
+	base64 basename bash bc beep bfsinfo
+	cal cat catattr checkfs checkitout chgrp chmod chop chown chroot cksum clear
+	clockconfig cmp collectcatkeys comm compress copyattr CortexAddOnHost cp
+	csplit cut date dc dd desklink df diff diff3 dircolors dirname
+	diskimage draggers driveinfo dstcheck du dumpcatalog
+	echo eject env error expand expr
+	factor false fdinfo ffm filepanel find finddir FirstBootPrompt fmt fold
+	fortune frcode ftp ftpd funzip fwcontrol
+	gawk gdb@x86 getlimits groupadd groupdel groupmod groups gzip gzexe
+	hd head hey hostname
+	id ident ifconfig <bin>install installsound iroster isvolume
+	ideinfo@ide idestatus@ide
+	join kernel_debugger keymap keystore kill
+	less lessecho lesskey link linkcatkeys listarea listattr listimage listdev
+	listport listres listsem listusb ln locale locate logger login logname ls
+	lsindex
+	mail2mbox makebootable mbox2mail md5sum merge message mimeset mkdos mkdir
+	mkfifo mkfs mkindex mktemp modifiers mount mount_nfs mountvolume mv
+	netcat netstat nl nohup notify nproc
+	od open
+	package package_repo passwd paste patch pathchk pc ping ping6 pkgman play
+	playfile playsound playwav pr prio printenv printf profile ps ptx pwd
+	query quit
+	rc readlink reindex release renice rlog rm rmattr rmindex rmdir roster
+	route
+	safemode screen_blanker screenmode screenshot sdiff setdecor setmime settype
+	setversion setvolume seq sha1sum sha256sum shar shred shuf shutdown sleep
+	sort spamdbm split stat strace stty su sum sync sysinfo
+	tac tail tcpdump tcptester tee telnet telnetd test timeout top touch
+	tr traceroute translate trash true truncate tsort tty
+	uname unchop unexpand unmount uniq unlink unshar unzip unzipsfx
+	<bin>updatedb uptime urlwrapper useradd userdel uudecode uuencode
+	vdir version vmstat
+	waitfor watch wc wget whoami writembr@x86 xargs xres
+	yes
+	zdiff zforce zgrep zip zipcloak <bin>zipgrep zipnote zipsplit zmore znew
+] ;
+
+SYSTEM_APPS = [ FFilterByBuildFeatures
+	AboutSystem ActivityMonitor BootManager@x86 CDPlayer CharacterMap
+	CodyCam Debugger DeskCalc Devices DiskProbe DiskUsage DriveSetup
+	Expander GLInfo@x86 HaikuDepot Icon-O-Matic Installer LaunchBox Magnify Mail
+	MediaConverter MediaPlayer MidiPlayer NetworkStatus PackageInstaller People
+	PoorMan PowerStatus ProcessController Screenshot ShowImage SoundRecorder
+	StyledEdit Terminal TextSearch TV WebWatch Workspaces
+] ;
+SYSTEM_PREFERENCES = [ FFilterByBuildFeatures
+	Appearance Backgrounds CPUFrequency DataTranslations
+	<preference>Deskbar E-mail FileTypes Keyboard Keymap Locale Media
+	Mouse Network Notifications Printers Screen ScreenSaver
+	Shortcuts Sounds Time Touchpad <preference>Tracker VirtualMemory
+] ;
+SYSTEM_DEMOS = [ FFilterByBuildFeatures
+	BSnow Chart Clock Cortex FontDemo GLTeapot@x86
+	$(HAIKU_INCLUDE_TRADEMARKS)Haiku3d@x86 Mandelbrot OverlayImage Pairs
+	PatchBay Playground Pulse Sudoku
+] ;
+
+
+rule HaikuImageGetSystemLibs
+{
+	return
+		# libs with special grist
+		[ MultiArchDefaultGristFiles libroot.so : revisioned ]
+		$(HAIKU_SHARED_LIBSTDC++_$(TARGET_PACKAGING_ARCH))
+		$(HAIKU_SHARED_LIBSUPC++_$(TARGET_PACKAGING_ARCH))
+		# libs with standard grist
+		[ MultiArchDefaultGristFiles [ FFilterByBuildFeatures
+			libbe.so libbsd.so libbnetapi.so
+			libdebug.so libdevice.so
+			libgame.so libGL.so@x86 libglut.so@x86
+			libgnu.so libmail.so libmedia.so libmidi.so libmidi2.so
+			libnetwork.so
+			libpackage.so
+			libscreensaver.so
+			libtextencoding.so libtiff.so libtracker.so libtranslation.so
+		] ]
+		;
+}
+
+
+rule HaikuImageGetPrivateSystemLibs
+{
+	return [ MultiArchDefaultGristFiles [ FFilterByBuildFeatures
+		libalm.so
+		libfluidsynth.so
+		libilmimf.so
+		libpackage-add-on-libsolv.so
+		libroot-addon-icu.so
+	] ] ;
+}
+
+
+SYSTEM_SERVERS = [ FFilterByBuildFeatures
+	app_server cddb_daemon debug_server dns_resolver_server input_server
+	keystore_server mail_daemon media_addon_server media_server midi_server
+	mount_server net_server nfs4_idmapper_server notification_server
+	package_daemon power_daemon print_server print_addon_server registrar
+	syslog_daemon
+] ;
+
+SYSTEM_NETWORK_DEVICES = ethernet loopback ;
+SYSTEM_NETWORK_DATALINK_PROTOCOLS = ethernet_frame <module>arp loopback_frame
+	ipv6_datagram ;
+#SYSTEM_NETWORK_PPP = ipcp modem pap pppoe ;
+SYSTEM_NETWORK_PROTOCOLS = ipv4 tcp udp icmp unix icmp6 ipv6 ;
+
+SYSTEM_ADD_ONS_ACCELERANTS = [ FFilterByBuildFeatures
+	x86,x86_64 @{
+		vesa.accelerant intel_extreme.accelerant
+	}@ # x86,x86_64
+	x86 @{
+		3dfx.accelerant ati.accelerant matrox.accelerant neomagic.accelerant
+		nvidia.accelerant intel_810.accelerant
+		radeon.accelerant radeon_hd.accelerant s3.accelerant
+		#via.accelerant vmware.accelerant
+	}@ # x86
+] ;
+SYSTEM_ADD_ONS_TRANSLATORS = BMPTranslator EXRTranslator GIFTranslator
+	HVIFTranslator ICOTranslator JPEGTranslator JPEG2000Translator
+	PCXTranslator PNGTranslator PPMTranslator
+	RAWTranslator RTFTranslator SGITranslator STXTTranslator TGATranslator
+	TIFFTranslator WebPTranslator WonderBrushTranslator ICNSTranslator
+;
+SYSTEM_ADD_ONS_LOCALE_CATALOGS = <catalog-addon>plaintext ;
+SYSTEM_ADD_ONS_MEDIA = [ FFilterByBuildFeatures
+	cortex_audioadapter.media_addon
+	cortex_flanger.media_addon
+	dvb.media_addon@x86
+	hmulti_audio.media_addon
+	mixer.media_addon
+	opensound.media_addon
+	tone_producer_demo.media_addon
+	usb_webcam.media_addon
+	video_producer_demo.media_addon
+	video_window_demo.media_addon
+	firewire_dv.media_addon@x86
+	#legacy.media_addon
+	equalizer.media_addon
+	vst_host.media_addon
+] ;
+SYSTEM_ADD_ONS_MEDIA_PLUGINS = [ FFilterByBuildFeatures
+	ffmpeg@ffmpeg raw_decoder
+] ;
+SYSTEM_ADD_ONS_PRINT =
+	Canon\ LIPS3\ Compatible
+	Canon\ LIPS4\ Compatible
+	Gutenprint
+	PCL5\ Compatible
+	PCL6\ Compatible
+	PDF\ Writer
+	PS\ Compatible
+	Preview
+;
+SYSTEM_ADD_ONS_PRINT_TRANSPORT = HP\ JetDirect IPP LPR
+	# Parallel\ Port
+	Print\ To\ File Serial\ Port USB\ Port
+;
+SYSTEM_ADD_ONS_SCREENSAVERS = [ FFilterByBuildFeatures
+	Butterfly DebugNow Flurry@x86
+	GLife@x86 $(HAIKU_INCLUDE_TRADEMARKS)Haiku Icons IFS Leaves
+	Message Spider Gravity@x86
+] ;
+SYSTEM_ADD_ONS_DRIVERS_AUDIO = auich auvia echo3g emuxki hda ice1712 sis7018 ;
+SYSTEM_ADD_ONS_DRIVERS_AUDIO_OLD = ; #cmedia usb_audio ;
+SYSTEM_ADD_ONS_DRIVERS_GRAPHICS = [ FFilterByBuildFeatures
+	x86,x86_64 @{
+		vesa intel_extreme
+	}@ # x86,x86_64
+	x86 @{
+		ati 3dfx intel_810 matrox neomagic nvidia radeon radeon_hd
+		s3 #via vmware
+	}@ # x86
+] ;
+SYSTEM_ADD_ONS_DRIVERS_MIDI = emuxki ice1712 usb_midi ;
+SYSTEM_ADD_ONS_DRIVERS_NET = [ FFilterByBuildFeatures
+	x86,x86_64 @{
+		3com atheros813x ar81xx attansic_l1 attansic_l2 broadcom440x
+		broadcom570x dec21xxx ipro100 ipro1000 jmicron2x0 marvell_yukon nforce
+		pcnet rtl8139 rtl81xx sis19x syskonnect via_rhine vt612x
+	}@ # x86_64
+
+	etherpci pegasus sis900 usb_davicom usb_asix usb_ecm wb840
+
+	# WLAN drivers
+	x86 @{
+		aironetwifi atheroswifi broadcom43xx
+		iprowifi2100 iprowifi2200 iprowifi3945
+		iprowifi4965 marvell88w8363 marvell88w8335
+		ralinkwifi wavelanwifi
+	}@ # x86
+
+	# WWAN drivers
+	#usb_beceemwmx@gpl
+] ;
+SYSTEM_ADD_ONS_DRIVERS_POWER = [ FFilterByBuildFeatures acpi_button@x86 ] ;
+SYSTEM_ADD_ONS_BUS_MANAGERS = [ FFilterByBuildFeatures
+	ata@ata pci ps2@x86,x86_64 isa@x86,x86_64
+	ide@ide scsi config_manager agp_gart@x86,x86_64 usb firewire@x86 acpi@x86
+	virtio random
+] ;
+SYSTEM_ADD_ONS_FILE_SYSTEMS = bfs bindfs btrfs cdda exfat ext2 fat iso9660 nfs
+	nfs4 attribute_overlay write_overlay ntfs packagefs reiserfs@x86 udf
+	googlefs ;
+
+
+# build the haiku system packages and add them
+include [ FDirName $(HAIKU_BUILD_RULES_DIR) HaikuPackages ] ;
+
+AddPackageFilesToHaikuImage system :
+	haiku.hpkg
+	haiku_$(TARGET_PACKAGING_ARCHS[2-]).hpkg
+	;
+AddPackageFilesToHaikuImage system : haiku_loader.hpkg ;
+
+
+AddSymlinkToHaikuImage home Desktop : /boot/home : Home ;
+
+# Mailbox folders and symlink
+AddDirectoryToHaikuImage home mail draft ;
+AddDirectoryToHaikuImage home mail in ;
+AddDirectoryToHaikuImage home mail out ;
+
+# global settings when a package is installed in ~/config
+AddDirectoryToHaikuImage home config settings global ;
+
+
+# scripts and data files
+local userBootScripts = UserBootscript UserSetupEnvironment.sample ;
+SEARCH on $(userBootScripts) = [ FDirName $(HAIKU_TOP) data config boot ] ;
+AddFilesToHaikuImage home config settings boot : $(userBootScripts) ;
+
+# Add boot launch directory
+AddDirectoryToHaikuImage home config settings boot launch ;
+
+# Add mail provider infos.
+AddFilesToHaikuImage home config settings Mail ProviderInfo :
+	$(HAIKU_PROVIDER_INFOS) ;
+
+# Add Tracker New Templates
+AddFilesToHaikuImage home config settings Tracker "Tracker New Templates"
+	:
+	"<tracker-new-templates>C++ header"
+	"<tracker-new-templates>C++ source"
+	"<tracker-new-templates>makefile"
+	"<tracker-new-templates>text file"
+;
+
+local etcDir = [ FDirName $(HAIKU_TOP) data etc ] ;
+local etcFiles = inputrc profile ;
+etcFiles = $(etcFiles:G=etc) ;
+SEARCH on $(etcFiles) = $(etcDir) ;
+etcFiles += <etc>termcap <etc>sysless <etc>sysless.in ;
+AddFilesToHaikuImage common settings etc : $(etcFiles) ;
+
+local profileFiles = [ Glob $(etcDir)/profile.d : *.sh ] ;
+profileFiles = $(profileFiles:G=profile-d) ;
+AddDirectoryToHaikuImage common settings etc profile.d ;
+AddFilesToHaikuImage common settings etc profile.d : $(profileFiles) ;
+
+#local bashCompletionFiles = [ Glob $(etcDir)/bash_completion.d : * ] ;
+#local bashCompletionHelperFiles
+#    = [ Glob $(etcDir)/bash_completion.d/helpers : * ] ;
+#bashCompletionFiles = $(bashCompletionFiles:G=bash-completion) ;
+#bashCompletionHelperFiles = $(bashCompletionHelperFiles:G=bash-completion-hlp) ;
+#AddDirectoryToHaikuImage common etc bash_completion.d ;
+#AddDirectoryToHaikuImage common etc bash_completion.d helpers ;
+#AddFilesToHaikuImage common etc bash_completion.d : $(bashCompletionFiles) ;
+#AddFilesToHaikuImage common etc bash_completion.d helpers
+#    : $(bashCompletionHelperFiles) ;
+
+local driverSettingsFiles = <driver-settings>kernel ;
+SEARCH on $(driverSettingsFiles)
+	= [ FDirName $(HAIKU_TOP) data settings kernel drivers ] ;
+AddFilesToHaikuImage home config settings kernel drivers
+	: $(driverSettingsFiles) ;
+
+local networkSettingsFiles = <network-settings>services ;
+SEARCH on $(networkSettingsFiles)
+	= [ FDirName $(HAIKU_TOP) data settings network ] ;
+AddFilesToHaikuImage common settings network : $(networkSettingsFiles) ;
+
+# fresh install indicator file for the post install scripts
+SEARCH on <post-install>fresh_install
+	= [ FDirName $(HAIKU_TOP) data common settings ] ;
+AddFilesToHaikuImage common settings : <post-install>fresh_install ;
+
+# decorators
+AddDirectoryToHaikuImage home config non-packaged add-ons decorators ;
+#AddFilesToHaikuImage home config add-ons decorators : ;
+
+# create directories that will remain empty
+AddDirectoryToHaikuImage common cache tmp ;
+AddDirectoryToHaikuImage common non-packaged ;
+AddDirectoryToHaikuImage common var empty ;
+AddDirectoryToHaikuImage common var log ;
+AddDirectoryToHaikuImage home Desktop ;
+AddDirectoryToHaikuImage home mail ;
+AddDirectoryToHaikuImage home config packages ;
+AddDirectoryToHaikuImage home config non-packaged bin ;
+AddDirectoryToHaikuImage home config non-packaged lib ;
+AddDirectoryToHaikuImage home config non-packaged add-ons kernel drivers bin ;
+AddDirectoryToHaikuImage home config non-packaged add-ons kernel drivers dev ;
+AddDirectoryToHaikuImage home config non-packaged add-ons input_server devices ;
+AddDirectoryToHaikuImage home config non-packaged add-ons input_server filters ;
+AddDirectoryToHaikuImage home config non-packaged add-ons input_server methods ;
+AddDirectoryToHaikuImage home config non-packaged add-ons media plugins ;
+AddDirectoryToHaikuImage home config non-packaged add-ons Tracker ;
+AddDirectoryToHaikuImage home config non-packaged add-ons Print ;
+AddDirectoryToHaikuImage home config non-packaged add-ons Screen\ Savers ;
+AddDirectoryToHaikuImage home config non-packaged add-ons Translators ;
+
+# printers
+AddDirectoryToHaikuImage home config settings printers Preview
+	: home-config-settings-printers-preview.rdef ;
+AddDirectoryToHaikuImage home config settings printers "Save as PDF"
+	: home-config-settings-printers-save-as-pdf.rdef ;
+
+# dvb channel settings
+CopyDirectoryToHaikuImage home config settings Media
+	: [ FDirName $(HAIKU_TOP) data settings media dvb ]
+	: dvb : -x Jamfile ;
+
+# repository config files
+local repository ;
+for repository in $(HAIKU_REPOSITORIES) {
+	AddFilesToHaikuImage common settings package-repositories
+		: [ on $(repository) return $(HAIKU_REPOSITORY_CONFIG_FILE) ]
+		: $(repository:G=) ;
+}
+
+
+include [ FDirName $(HAIKU_BUILD_RULES_DIR) images HaikuImageCommon ] ;

build/jam/images/HaikuImageBootstrap

@@ -0,0 +1,263 @@
+# This file defines what ends up on the Haiku bootstrap image (respectively in
+# the Haiku installation directory) and it executes the rules building the image
+# (respectively installing the files in the installation directory).
+
+
+SYSTEM_BIN = [ FFilterByBuildFeatures
+	"["
+	addattr alert arp
+	base64 basename bash bc beep bfsinfo
+	cal cat catattr checkfs checkitout chgrp chmod chop chown chroot cksum clear
+	clockconfig cmp collectcatkeys comm compress copyattr CortexAddOnHost cp
+	csplit cut date dc dd desklink df diff diff3 dircolors dirname
+	diskimage draggers driveinfo dstcheck du dumpcatalog
+	echo eject env error expand expr
+	factor false fdinfo ffm filepanel find finddir fmt fold
+	fortune frcode ftp ftpd funzip
+	gawk gdb@x86 getlimits groupadd groupdel groupmod groups gzip gzexe
+	hd head hey hostname
+	id ident ifconfig <bin>install isvolume
+	ideinfo@ide idestatus@ide
+	join kernel_debugger keymap keystore kill
+	less lessecho lesskey link linkcatkeys listarea listattr listimage listdev
+	listport listres listsem listusb ln locale locate logger login logname ls
+	lsindex
+	makebootable md5sum merge message mimeset mkdir
+	mkfifo mkfs mkindex mktemp modifiers mount mountvolume mv
+	netcat netstat nl nohup notify nproc
+	od open
+	package package_repo passwd paste patch pathchk pc ping ping6 pkgman
+	pr prio printenv printf profile ps ptx pwd
+	query quit
+	rc readlink reindex release renice rlog rm rmattr rmindex rmdir roster
+	route
+	safemode screen_blanker screenmode sdiff setmime settype
+	setversion setvolume seq sha1sum sha256sum shar shred shuf shutdown sleep
+	sort split stat strace stty su sum sync sysinfo
+	tac tail tcpdump tcptester tee telnet telnetd test timeout top touch
+	tr traceroute trash true truncate tsort tty
+	uname unchop unexpand unmount uniq unlink unshar unzip unzipsfx
+	<bin>updatedb uptime urlwrapper useradd userdel uudecode uuencode
+	vdir version vmstat
+	waitfor watch wc wget whoami writembr@x86 xargs xres
+	yes
+	zdiff zforce zgrep zip zipcloak <bin>zipgrep zipnote zipsplit zmore znew
+] ;
+
+SYSTEM_APPS = [ FFilterByBuildFeatures
+	AboutSystem ActivityMonitor BootManager@x86 CharacterMap
+	DeskCalc Debugger Devices DiskProbe DiskUsage DriveSetup
+	Expander Installer LaunchBox
+	NetworkStatus PackageInstaller
+	PowerStatus ProcessController ShowImage
+	StyledEdit Terminal TextSearch Workspaces
+] ;
+SYSTEM_PREFERENCES = [ FFilterByBuildFeatures
+	Appearance Backgrounds CPUFrequency
+	<preference>Deskbar FileTypes Keyboard Keymap Locale
+	Mouse Network Notifications Screen ScreenSaver
+	Shortcuts Time Touchpad <preference>Tracker VirtualMemory
+] ;
+SYSTEM_DEMOS = ;
+
+
+rule HaikuImageGetSystemLibs
+{
+	return
+		# libs with special grist
+		[ MultiArchDefaultGristFiles libroot.so : revisioned ]
+		$(HAIKU_SHARED_LIBSTDC++_$(TARGET_PACKAGING_ARCH))
+		$(HAIKU_SHARED_LIBSUPC++_$(TARGET_PACKAGING_ARCH))
+		# libs with standard grist
+		[ MultiArchDefaultGristFiles [ FFilterByBuildFeatures
+			libbe.so libbsd.so libbnetapi.so
+			libdebug.so libdevice.so
+			libgame.so
+			libgnu.so libmail.so libmedia.so libmidi.so libmidi2.so
+			libnetwork.so
+			libpackage.so
+			libscreensaver.so
+			libtextencoding.so libtracker.so libtranslation.so
+		] ]
+		;
+}
+
+
+rule HaikuImageGetPrivateSystemLibs
+{
+	return [ MultiArchDefaultGristFiles [ FFilterByBuildFeatures
+		libalm.so
+		libfluidsynth.so
+#		libilmimf.so
+		libpackage-add-on-libsolv.so
+		libroot-addon-icu.so
+	] ] ;
+}
+
+
+SYSTEM_SERVERS = [ FFilterByBuildFeatures
+	app_server debug_server dns_resolver_server input_server
+	keystore_server media_addon_server
+	mount_server net_server notification_server
+	package_daemon power_daemon registrar
+	syslog_daemon
+] ;
+
+SYSTEM_NETWORK_DEVICES = ethernet loopback ;
+SYSTEM_NETWORK_DATALINK_PROTOCOLS = ethernet_frame <module>arp loopback_frame
+	ipv6_datagram ;
+#SYSTEM_NETWORK_PPP = ipcp modem pap pppoe ;
+SYSTEM_NETWORK_PROTOCOLS = ipv4 tcp udp icmp unix icmp6 ipv6 ;
+
+SYSTEM_ADD_ONS_ACCELERANTS = [ FFilterByBuildFeatures
+	x86,x86_64 @{
+		vesa.accelerant
+	}@ # x86,x86_64
+	x86 @{
+		3dfx.accelerant ati.accelerant matrox.accelerant neomagic.accelerant
+		nvidia.accelerant intel_810.accelerant intel_extreme.accelerant
+		radeon.accelerant radeon_hd.accelerant s3.accelerant 
+		#via.accelerant vmware.accelerant
+	}@ # x86
+] ;
+SYSTEM_ADD_ONS_TRANSLATORS = STXTTranslator ;
+SYSTEM_ADD_ONS_LOCALE_CATALOGS = <catalog-addon>plaintext ;
+SYSTEM_ADD_ONS_MEDIA = ;
+SYSTEM_ADD_ONS_MEDIA_PLUGINS =  ;
+SYSTEM_ADD_ONS_PRINT = ;
+SYSTEM_ADD_ONS_PRINT_TRANSPORT = ;
+SYSTEM_ADD_ONS_SCREENSAVERS = ;
+SYSTEM_ADD_ONS_DRIVERS_AUDIO = ;
+SYSTEM_ADD_ONS_DRIVERS_AUDIO_OLD = ;
+SYSTEM_ADD_ONS_DRIVERS_GRAPHICS = [ FFilterByBuildFeatures
+	x86,x86_64 @{
+		vesa
+	}@ # x86,x86_64
+	x86 @{
+		ati 3dfx intel_810 intel_extreme matrox neomagic nvidia radeon radeon_hd
+		s3 #via vmware
+	}@ # x86
+] ;
+SYSTEM_ADD_ONS_DRIVERS_MIDI = ;
+SYSTEM_ADD_ONS_DRIVERS_NET = [ FFilterByBuildFeatures
+	x86,x86_64 @{
+		3com atheros813x ar81xx attansic_l1 attansic_l2 broadcom440x
+		broadcom570x dec21xxx ipro100 ipro1000 jmicron2x0 marvell_yukon nforce
+		pcnet rtl8139 rtl81xx sis19x syskonnect via_rhine vt612x
+	}@ # x86_64
+
+	etherpci pegasus sis900 usb_davicom usb_asix usb_ecm wb840
+
+	# WLAN drivers
+	x86 @{
+		aironetwifi atheroswifi broadcom43xx
+		iprowifi2100 iprowifi2200 iprowifi3945
+		iprowifi4965 marvell88w8363 marvell88w8335
+		ralinkwifi wavelanwifi
+	}@ # x86
+
+	# WWAN drivers
+	#usb_beceemwmx@gpl
+] ;
+SYSTEM_ADD_ONS_DRIVERS_POWER = [ FFilterByBuildFeatures acpi_button@x86 ] ;
+SYSTEM_ADD_ONS_BUS_MANAGERS = [ FFilterByBuildFeatures
+	ata@ata pci ps2@x86,x86_64 isa@x86,x86_64
+	ide@ide scsi config_manager agp_gart@x86 usb firewire@x86 acpi@x86
+	virtio
+] ;
+SYSTEM_ADD_ONS_FILE_SYSTEMS = bfs bindfs btrfs exfat ext2 fat iso9660
+	attribute_overlay write_overlay ntfs packagefs reiserfs@x86 udf ;
+
+
+# build the haiku system packages and add them
+include [ FDirName $(HAIKU_BUILD_RULES_DIR) HaikuPackages ] ;
+
+AddPackageFilesToHaikuImage system :
+	haiku.hpkg
+	haiku_$(TARGET_PACKAGING_ARCHS[2-]).hpkg
+	;
+AddPackageFilesToHaikuImage system : haiku_loader.hpkg ;
+
+
+# build and add the source package directory and a haikuports.config file
+CopyDirectoryToHaikuImage home haikuports
+	: [ BuildHaikuPortsSourcePackageDirectory ]
+	: input-source-packages : : isTarget ;
+AddFilesToHaikuImage home haikuports
+	: [ BuildHaikuPortsRepositoryConfig /boot/home/haikuports ] ;
+
+
+AddSymlinkToHaikuImage home Desktop : /boot/home : Home ;
+
+# global settings when a package is installed in ~/config
+AddDirectoryToHaikuImage home config settings global ;
+
+
+# scripts and data files
+local userBootScripts = UserBootscript UserSetupEnvironment.sample ;
+SEARCH on $(userBootScripts) = [ FDirName $(HAIKU_TOP) data config boot ] ;
+AddFilesToHaikuImage home config settings boot : $(userBootScripts) ;
+
+# Add boot launch directory
+AddDirectoryToHaikuImage home config settings boot launch ;
+
+# Add Tracker New Templates
+AddFilesToHaikuImage home config settings Tracker "Tracker New Templates"
+	:
+	"<tracker-new-templates>C++ header"
+	"<tracker-new-templates>C++ source"
+	"<tracker-new-templates>makefile"
+	"<tracker-new-templates>text file"
+;
+
+local etcDir = [ FDirName $(HAIKU_TOP) data etc ] ;
+local etcFiles = inputrc profile ;
+etcFiles = $(etcFiles:G=etc) ;
+SEARCH on $(etcFiles) = $(etcDir) ;
+etcFiles += <etc>termcap <etc>sysless <etc>sysless.in ;
+AddFilesToHaikuImage common settings etc : $(etcFiles) ;
+
+local profileFiles = [ Glob $(etcDir)/profile.d : *.sh ] ;
+profileFiles = $(profileFiles:G=profile-d) ;
+AddDirectoryToHaikuImage common settings etc profile.d ;
+AddFilesToHaikuImage common settings etc profile.d : $(profileFiles) ;
+
+local driverSettingsFiles = <driver-settings>kernel ;
+SEARCH on $(driverSettingsFiles)
+	= [ FDirName $(HAIKU_TOP) data settings kernel drivers ] ;
+AddFilesToHaikuImage home config settings kernel drivers
+	: $(driverSettingsFiles) ;
+
+local networkSettingsFiles = <network-settings>services ;
+SEARCH on $(networkSettingsFiles)
+	= [ FDirName $(HAIKU_TOP) data settings network ] ;
+AddFilesToHaikuImage common settings network : $(networkSettingsFiles) ;
+
+# fresh install indicator file for the post install scripts
+SEARCH on <post-install>fresh_install
+	= [ FDirName $(HAIKU_TOP) data common settings ] ;
+AddFilesToHaikuImage common settings : <post-install>fresh_install ;
+
+# create directories that will remain empty
+AddDirectoryToHaikuImage common cache tmp ;
+AddDirectoryToHaikuImage common non-packaged ;
+AddDirectoryToHaikuImage common var empty ;
+AddDirectoryToHaikuImage common var log ;
+AddDirectoryToHaikuImage home Desktop ;
+AddDirectoryToHaikuImage home mail ;
+AddDirectoryToHaikuImage home config packages ;
+AddDirectoryToHaikuImage home config non-packaged bin ;
+AddDirectoryToHaikuImage home config non-packaged lib ;
+AddDirectoryToHaikuImage home config non-packaged add-ons kernel drivers bin ;
+AddDirectoryToHaikuImage home config non-packaged add-ons kernel drivers dev ;
+AddDirectoryToHaikuImage home config non-packaged add-ons input_server devices ;
+AddDirectoryToHaikuImage home config non-packaged add-ons input_server filters ;
+AddDirectoryToHaikuImage home config non-packaged add-ons input_server methods ;
+AddDirectoryToHaikuImage home config non-packaged add-ons media plugins ;
+AddDirectoryToHaikuImage home config non-packaged add-ons Tracker ;
+AddDirectoryToHaikuImage home config non-packaged add-ons Print ;
+AddDirectoryToHaikuImage home config non-packaged add-ons Screen\ Savers ;
+AddDirectoryToHaikuImage home config non-packaged add-ons Translators ;
+
+
+include [ FDirName $(HAIKU_BUILD_RULES_DIR) images HaikuImageCommon ] ;

build/jam/images/HaikuImageCommon

@@ -0,0 +1,157 @@
+#pragma mark - Optional Packages
+
+
+include [ FDirName $(HAIKU_BUILD_RULES_DIR) OptionalPackages ] ;
+include [ FDirName $(HAIKU_BUILD_RULES_DIR) OptionalTestPackages ] ;
+
+
+#pragma mark - User/Group Setup
+
+
+# add the root user and the root and users groups
+AddUserToHaikuImage $(HAIKU_ROOT_USER_NAME:E=baron) : 0 : 0 : /boot/home
+	: /bin/bash : $(HAIKU_ROOT_USER_REAL_NAME:E="Root User") ;
+AddGroupToHaikuImage root : 0 : ;
+AddGroupToHaikuImage users : 100 : ;
+
+
+#pragma mark - Host Name
+
+
+if $(HAIKU_IMAGE_HOST_NAME) {
+	actions BuildHaikuImageHostnameFile
+	{
+		echo "$(HAIKU_IMAGE_HOST_NAME)" > $(1)
+	}
+
+	local file = <haiku-image>hostname ;
+	Always $(file) ;
+	MakeLocate $(file) : $(HAIKU_COMMON_PLATFORM_OBJECT_DIR) ;
+	BuildHaikuImageHostnameFile $(file) ;
+	AddFilesToHaikuImage common settings network : $(file) ;
+}
+
+
+#pragma mark - Build The Image
+
+
+# Execute pre-image user config rules.
+UserBuildConfigRulePreImage	;
+
+# Set image name and directory defaults and locate the image.
+HAIKU_IMAGE_NAME ?= $(HAIKU_DEFAULT_IMAGE_NAME) ;
+HAIKU_IMAGE_DIR ?= $(HAIKU_DEFAULT_IMAGE_DIR) ;
+HAIKU_IMAGE = $(HAIKU_IMAGE_NAME) ;
+HAIKU_IMAGE_SIZE ?= $(HAIKU_DEFAULT_IMAGE_SIZE) ; # 300 MB
+HAIKU_IMAGE_LABEL ?= $(HAIKU_DEFAULT_IMAGE_LABEL) ;
+MakeLocate $(HAIKU_IMAGE) : $(HAIKU_IMAGE_DIR) ;
+
+# Set the default installation directory.
+HAIKU_INSTALL_DIR ?= $(HAIKU_DEFAULT_INSTALL_DIR) ;
+
+# the pseudo target all image contents is attached to
+NotFile $(HAIKU_IMAGE_CONTAINER_NAME) ;
+
+# prepare the script that initializes the shell variables
+HAIKU_IMAGE_INIT_VARIABLES_SCRIPT = <HaikuImage>haiku.image-init-vars ;
+local script = $(HAIKU_IMAGE_INIT_VARIABLES_SCRIPT) ;
+MakeLocate $(script) : $(HAIKU_OUTPUT_DIR) ;
+Always $(script) ;
+
+AddVariableToScript $(script) : sourceDir : $(HAIKU_TOP) ;
+AddVariableToScript $(script) : outputDir : $(HAIKU_OUTPUT_DIR) ;
+AddVariableToScript $(script) : tmpDir : $(HAIKU_TMP_DIR) ;
+AddVariableToScript $(script) : installDir : $(HAIKU_INSTALL_DIR) ;
+#AddVariableToScript $(script) : isImage : 1 ;
+AddVariableToScript $(script) : imageSize : $(HAIKU_IMAGE_SIZE) ;
+AddVariableToScript $(script) : imageLabel : $(HAIKU_IMAGE_LABEL) ;
+AddVariableToScript $(script) : addBuildCompatibilityLibDir
+	: $(HOST_ADD_BUILD_COMPATIBILITY_LIB_DIR) ;
+AddVariableToScript $(script) : dontClearImage : $(HAIKU_DONT_CLEAR_IMAGE) ;
+AddVariableToScript $(script) : updateOnly : [ IsUpdateHaikuImageOnly ] ;
+AddTargetVariableToScript $(script) : <build>addattr ;
+AddTargetVariableToScript $(script) : <build>bfs_shell : bfsShell ;
+AddTargetVariableToScript $(script) : <build>fs_shell_command : fsShellCommand ;
+AddTargetVariableToScript $(script) : <build>copyattr ;
+AddTargetVariableToScript $(script) : <build>create_image : createImage ;
+AddTargetVariableToScript $(script) : <build>makebootable ;
+AddTargetVariableToScript $(script) : <build>rc ;
+AddTargetVariableToScript $(script) : <build>resattr ;
+AddTargetVariableToScript $(script) : <build>unzip ;
+AddTargetVariableToScript $(script) : <build>vmdkimage ;
+if $(HOST_RM_ATTRS_TARGET) {
+	AddTargetVariableToScript $(script) : $(HOST_RM_ATTRS_TARGET) : rmAttrs ;
+} else {
+	AddVariableToScript $(script) : rmAttrs : rm ;
+}
+
+AddPackagesAndRepositoryVariablesToContainerScript $(script)
+	: $(HAIKU_IMAGE_CONTAINER_NAME) ;
+
+# create the other scripts
+HAIKU_IMAGE_MAKE_DIRS_SCRIPT = <HaikuImage>haiku.image-make-dirs ;
+HAIKU_IMAGE_COPY_FILES_SCRIPT = <HaikuImage>haiku.image-copy-files ;
+HAIKU_IMAGE_EXTRACT_FILES_SCRIPT = <HaikuImage>haiku.image-extract-files ;
+MakeLocate $(HAIKU_IMAGE_MAKE_DIRS_SCRIPT) $(HAIKU_IMAGE_COPY_FILES_SCRIPT)
+	$(HAIKU_IMAGE_EXTRACT_FILES_SCRIPT) : $(HAIKU_OUTPUT_DIR) ;
+
+CreateHaikuImageMakeDirectoriesScript $(HAIKU_IMAGE_MAKE_DIRS_SCRIPT) ;
+CreateHaikuImageCopyFilesScript $(HAIKU_IMAGE_COPY_FILES_SCRIPT) ;
+CreateHaikuImageExtractFilesScript $(HAIKU_IMAGE_EXTRACT_FILES_SCRIPT) ;
+
+# Convenience wrapper rule around BuildHaikuImage.
+rule _BuildHaikuImage image : isImage : isVMwareImage
+{
+	# _BuildHaikuImage <image target> : <isImage> : <isVMwareImage> ;
+	#
+
+	# build the image
+	# HAIKU_IMAGE_EARLY_USER_SCRIPTS, HAIKU_IMAGE_LATE_USER_SCRIPTS can be
+	# specified by the user.
+	BuildHaikuImage $(image) :
+		$(HAIKU_IMAGE_INIT_VARIABLES_SCRIPT)
+		$(HAIKU_IMAGE_EARLY_USER_SCRIPTS)
+		$(HAIKU_IMAGE_MAKE_DIRS_SCRIPT)
+		$(HAIKU_IMAGE_COPY_FILES_SCRIPT)
+		$(HAIKU_IMAGE_EXTRACT_FILES_SCRIPT)
+		$(HAIKU_IMAGE_LATE_USER_SCRIPTS)
+		: $(isImage)
+		: $(isVMwareImage)
+	;
+
+	# remove the scripts we have generated
+	RmTemps $(image) :
+		$(HAIKU_IMAGE_INIT_VARIABLES_SCRIPT)
+		$(HAIKU_IMAGE_MAKE_DIRS_SCRIPT)
+		$(HAIKU_IMAGE_COPY_FILES_SCRIPT)
+		$(HAIKU_IMAGE_EXTRACT_FILES_SCRIPT)
+	;
+}
+
+# build the image
+_BuildHaikuImage $(HAIKU_IMAGE) : true ;
+NotFile haiku-image ;
+Depends haiku-image : $(HAIKU_IMAGE) ;
+
+
+# install Haiku into a directory
+NotFile install-haiku ;
+_BuildHaikuImage install-haiku : 0 ;
+
+
+# build the VMware image
+HAIKU_VMWARE_IMAGE_NAME ?= $(HAIKU_DEFAULT_VMWARE_IMAGE_NAME) ;
+HAIKU_VMWARE_IMAGE = $(HAIKU_VMWARE_IMAGE_NAME) ;
+MakeLocate $(HAIKU_VMWARE_IMAGE) : $(HAIKU_IMAGE_DIR) ;
+
+_BuildHaikuImage $(HAIKU_VMWARE_IMAGE) : true : true ;
+NotFile haiku-vmware-image ;
+Depends haiku-vmware-image : $(HAIKU_VMWARE_IMAGE) ;
+
+
+# create a package list
+BuildHaikuImagePackageList $(HAIKU_IMAGE_LIST_PACKAGES_TARGET) ;
+
+
+# Execute post-image user config rules.
+UserBuildConfigRulePostImage ;

build/jam/images/NetBootArchive

@@ -35,7 +35,8 @@ AddFilesToNetBootArchive system add-ons kernel busses ide
 	: generic_ide_pci ide_isa@x86 silicon_image_3112 ;
 AddFilesToNetBootArchive system add-ons kernel busses scsi
 	: ahci ;
-AddFilesToNetBootArchive system add-ons kernel console : vga_text ;
+AddFilesToNetBootArchive system add-ons kernel console
+	: vga_text ;
 AddFilesToNetBootArchive system add-ons kernel file_systems
 	: $(SYSTEM_ADD_ONS_FILE_SYSTEMS) ;
 AddFilesToNetBootArchive system add-ons kernel generic
@@ -46,7 +47,8 @@ AddFilesToNetBootArchive system add-ons kernel interrupt_controllers
 	: openpic@ppc ;
 
 if $(TARGET_ARCH) = x86 {
-	AddFilesToNetBootArchive system add-ons kernel cpu : generic_x86 ;
+	AddFilesToNetBootArchive system add-ons kernel cpu
+		: generic_x86 ;
 }
 
 # drivers
@@ -56,7 +58,8 @@ AddDriversToNetBootArchive disk virtual	: remote_disk ;
 AddDriversToNetBootArchive net : $(SYSTEM_ADD_ONS_DRIVERS_NET) ;
 
 # kernel
-AddFilesToNetBootArchive system : <revisioned>kernel_$(TARGET_ARCH) ;
+AddFilesToNetBootArchive system
+	: <revisioned>kernel_$(TARGET_ARCH) ;
 
 # scripts and data files
 
@@ -71,11 +74,13 @@ AddFilesToNetBootArchive system add-ons kernel network
 	: <net>notifications stack ;
 AddFilesToNetBootArchive system add-ons kernel network devices
 	: $(SYSTEM_NETWORK_DEVICES) ;
-AddFilesToNetBootArchive system add-ons kernel network datalink_protocols
+AddFilesToNetBootArchive
+	system add-ons kernel network datalink_protocols
 	: $(SYSTEM_NETWORK_DATALINK_PROTOCOLS) ;
 AddFilesToNetBootArchive system add-ons kernel network ppp
 	: $(SYSTEM_NETWORK_PPP) ;
-AddFilesToNetBootArchive system add-ons kernel network protocols
+AddFilesToNetBootArchive
+	system add-ons kernel network protocols
 	: $(SYSTEM_NETWORK_PROTOCOLS) ;
 
 # boot module links

build/jam/packages/Haiku

@@ -0,0 +1,393 @@
+local architecture = $(HAIKU_PACKAGING_ARCHS[1]) ;
+
+
+local haikuPackage = haiku.hpkg ;
+HaikuPackage $(haikuPackage) ;
+
+
+# wifi firmware
+for driver in $(SYSTEM_ADD_ONS_DRIVERS_NET) {
+	local package = [ on $(driver) return $(HAIKU_WIFI_FIRMWARE_PACKAGE) ] ;
+	local archive = [ on $(driver) return $(HAIKU_WIFI_FIRMWARE_ARCHIVE) ] ;
+	local extract = [ on $(driver) return $(HAIKU_WIFI_FIRMWARE_DO_EXTRACT) ] ;
+	if $(archive) {
+		AddWifiFirmwareToPackage $(driver) : $(package) : $(archive)
+			: $(extract) ;
+	}
+	local packages = [ on $(driver) return $(HAIKU_WIFI_FIRMWARE_PACKAGES) ] ;
+	local archives = [ on $(driver) return $(HAIKU_WIFI_FIRMWARE_ARCHIVES) ] ;
+	for archive in $(archives) {
+		AddWifiFirmwareToPackage $(driver) : $(packages[1]) : $(archive)
+			: $(extract) ;
+		packages = $(packages[2-]) ;
+	}
+}
+
+
+# modules
+AddFilesToPackage add-ons kernel bus_managers : $(SYSTEM_ADD_ONS_BUS_MANAGERS) ;
+AddFilesToPackage add-ons kernel busses agp_gart : <agp_gart>intel@x86,x86_64 ;
+
+if $(HAIKU_ATA_STACK) = 1 {
+	AddFilesToPackage add-ons kernel busses ata
+		: generic_ide_pci it8211 legacy_sata silicon_image_3112 ide_isa@x86 ;
+} else {
+	AddFilesToPackage add-ons kernel busses ide
+		: generic_ide_pci it8211 legacy_sata silicon_image_3112 ide_isa@x86 ;
+}
+
+AddFilesToPackage add-ons kernel busses random : virtio_rng ;
+AddFilesToPackage add-ons kernel busses scsi : ahci virtio_scsi ;
+AddFilesToPackage add-ons kernel busses usb : <usb>uhci <usb>ohci <usb>ehci ;
+AddFilesToPackage add-ons kernel busses virtio : virtio_pci ;
+AddFilesToPackage add-ons kernel console : vga_text ;
+AddFilesToPackage add-ons kernel debugger
+	: <kdebug>demangle <kdebug>disasm@x86 <kdebug>hangman
+	  <kdebug>invalidate_on_exit <kdebug>usb_keyboard <kdebug>qrencode
+	  <kdebug>run_on_exit ;
+AddFilesToPackage add-ons kernel file_systems : $(SYSTEM_ADD_ONS_FILE_SYSTEMS) ;
+AddFilesToPackage add-ons kernel generic
+	: ata_adapter@ata bios@x86,x86_64 dpc ide_adapter@ide
+		locked_pool mpu401 scsi_periph <module>tty ;
+AddFilesToPackage add-ons kernel partitioning_systems
+	: amiga_rdb apple efi_gpt intel session ;
+AddFilesToPackage add-ons kernel interrupt_controllers : openpic@ppc ;
+
+if $(TARGET_ARCH) = x86 || $(TARGET_ARCH) = x86_64 {
+	AddFilesToPackage add-ons kernel cpu : generic_x86 ;
+}
+
+# drivers
+AddNewDriversToPackage disk scsi	: scsi_cd scsi_disk ;
+AddNewDriversToPackage disk virtual : virtio_block ;
+AddNewDriversToPackage power		: enhanced_speedstep@x86 ;
+AddNewDriversToPackage power		: acpi_battery@x86 ;
+#AddNewDriversToPackage display		: display_controls@x86 ;
+
+# legacy drivers
+AddDriversToPackage					: console dprintf null <driver>tty zero ;
+AddDriversToPackage audio hmulti	: $(SYSTEM_ADD_ONS_DRIVERS_AUDIO) ;
+AddDriversToPackage audio old		: $(SYSTEM_ADD_ONS_DRIVERS_AUDIO_OLD) ;
+AddDriversToPackage midi			: $(SYSTEM_ADD_ONS_DRIVERS_MIDI) ;
+AddDriversToPackage bus				: usb_raw fw_raw@x86 ;
+AddDriversToPackage disk floppy		: pc_floppy@x86 ;
+AddDriversToPackage disk usb		: usb_disk ;
+AddDriversToPackage disk usb		: usb_floppy ;
+AddDriversToPackage printer usb		: usb_printer ;
+AddDriversToPackage disk virtual	: nbd ;
+AddDriversToPackage dvb				: cx23882 ;
+AddDriversToPackage graphics		: $(SYSTEM_ADD_ONS_DRIVERS_GRAPHICS) ;
+AddDriversToPackage input			: ps2_hid usb_hid wacom ;
+AddDriversToPackage misc			: <driver>poke <driver>mem ;
+AddDriversToPackage net				: $(SYSTEM_ADD_ONS_DRIVERS_NET) ;
+AddDriversToPackage ports			: usb_serial ;
+AddDriversToPackage power			: $(SYSTEM_ADD_ONS_DRIVERS_POWER) ;
+
+# kernel
+AddFilesToPackage : <revisioned>kernel_$(TARGET_ARCH) ;
+
+# libs
+AddLibrariesToPackage lib
+	: [ HaikuImageGetSystemLibs ] [ HaikuImageGetPrivateSystemLibs ] ;
+
+# libnetwork.so replaces quite a few libraries
+if $(HAIKU_GCC_VERSION_$(architecture)[1]) = 2 {
+	local libNetworkAliases = libsocket.so libbind.so libnet.so ;
+	local lib ;
+	for lib in $(libNetworkAliases) {
+		AddSymlinkToPackage lib : libnetwork.so : $(lib) ;
+	}
+
+	AddSymlinkToPackage lib : libbnetapi.so : libnetapi.so ;
+}
+
+
+# TODO: Remove when the packages have been rebuilt!
+AddSymlinkToPackage lib : libbe.so : liblocale.so ;
+
+# servers
+AddFilesToPackage servers : $(SYSTEM_SERVERS) ;
+
+# apps
+AddFilesToPackage  				: runtime_loader Deskbar Tracker ;
+AddFilesToPackage bin			: $(SYSTEM_BIN) consoled ;
+AddFilesToPackage apps			: $(SYSTEM_APPS) ;
+AddFilesToPackage preferences	: $(SYSTEM_PREFERENCES) ;
+AddFilesToPackage demos			: $(SYSTEM_DEMOS) ;
+
+SEARCH on which = [ FDirName $(HAIKU_TOP) data bin ] ;
+AddFilesToPackage bin : which ;
+SEARCH on install-wifi-firmwares.sh = [ FDirName $(HAIKU_TOP) data bin ] ;
+AddFilesToPackage bin : install-wifi-firmwares.sh ;
+
+AddSymlinkToPackage bin : bash : sh ;
+AddSymlinkToPackage bin : trash : untrash ;
+AddSymlinkToPackage bin : less : more ;
+AddSymlinkToPackage bin : gzip : gunzip ;
+AddSymlinkToPackage bin : gzip : zcat ;
+AddSymlinkToPackage bin : zdiff : zcmp ;
+AddSymlinkToPackage bin : unzip : zipinfo ;
+AddSymlinkToPackage bin : gawk : awk ;
+
+# scripts and data files
+local bootScripts = Bootscript Bootscript.cd SetupEnvironment Netscript
+	InstallerInitScript InstallerFinishScript ;
+SEARCH on $(bootScripts) = [ FDirName $(HAIKU_TOP) data system boot ] ;
+AddFilesToPackage boot : $(bootScripts) ;
+
+# post install scripts
+local postInstallFiles = add_catalog_entry_attributes.sh
+	default_deskbar_items.sh ;
+postInstallFiles = $(postInstallFiles:G=post-install) ;
+SEARCH on $(postInstallFiles)
+	= [ FDirName $(HAIKU_TOP) data common boot post_install ] ;
+AddFilesToPackage boot post-install : $(postInstallFiles) ;
+
+# Gutenprint data files
+CopyDirectoryToPackage data
+	: [ FDirName $(HAIKU_TOP) src libs print libgutenprint src xml ]
+	: gutenprint : -x *.c -x Makefile.am -x Makefile.in ;
+
+# artwork and sounds
+local logoArtwork =
+	$(HAIKU_INCLUDE_TRADEMARKS)"HAIKU logo - white on blue - big.png"
+	$(HAIKU_INCLUDE_TRADEMARKS)"HAIKU logo - white on blue - normal.png" ;
+SEARCH on $(logoArtwork) = [ FDirName $(HAIKU_TOP) data artwork ] ;
+AddFilesToPackage data artwork : $(logoArtwork) ;
+
+# Mail spell check dictionaries
+local spellFiles = words geekspeak ;
+spellFiles = $(spellFiles:G=spell) ;
+SEARCH on $(spellFiles) = [ FDirName $(HAIKU_TOP) src apps mail ] ;
+AddFilesToPackage data spell_check word_dictionary : $(spellFiles) ;
+
+local fortuneFiles = [ Glob $(HAIKU_TOP)/data/system/data/fortunes
+	: [a-zA-Z0-9]* ] ;
+fortuneFiles = $(fortuneFiles:G=data!fortunes) ;
+AddFilesToPackage data fortunes : $(fortuneFiles) ;
+
+local fontDir = [ FDirName $(HAIKU_TOP) data system data fonts ] ;
+local psFonts = [ Glob $(fontDir)/psfonts : *.afm *.pfb ] ;
+local ttFonts = [ Glob $(fontDir)/ttfonts : *.ttf ] ;
+AddFilesToPackage data fonts psfonts : $(psFonts) ;
+AddFilesToPackage data fonts ttfonts : $(ttFonts) ;
+
+local cannaDir = [ FDirName $(HAIKU_TOP) data system data Canna ] ;
+local cannaDefault = [ Glob $(cannaDir)/default : *.canna *.gz ] ;
+local cannaDic = [ Glob $(cannaDir)/dic : *.cbp ] ;
+local cannaDicCanna = [ Glob $(cannaDir)/dic/canna
+	: *.cld *.ctd *.cbd *.dir ] ;
+AddFilesToPackage data Canna default	: $(cannaDefault) ;
+AddFilesToPackage data Canna dic		: $(cannaDic) ;
+AddFilesToPackage data Canna dic canna	: $(cannaDicCanna) ;
+#AddDirectoryToPackage data Canna dic group ;
+#AddDirectoryToPackage data Canna dic user ;
+	# TODO: If those serve any purpose, they should probably live in a writable
+	# subtree.
+
+local keymapFiles = [ Glob [ FDirName $(HAIKU_TOP) src data keymaps ]
+	: *.keymap ] ;
+keymapFiles = $(keymapFiles:BG=keymap) ;
+AddFilesToPackage data Keymaps : $(keymapFiles) ;
+AddSymlinkToPackage data Keymaps : Swedish : Finnish ;
+AddSymlinkToPackage data Keymaps : Slovene : Croatian ;
+AddSymlinkToPackage data Keymaps : US-International : Brazilian ;
+
+# Copy keyboard layout files to the image one-by-one.
+local keyboardLayoutsDir
+	= [ FDirName $(HAIKU_TOP) data system data KeyboardLayouts ] ;
+local keyboardLayoutFiles =
+	"Generic 104-key"
+	"Generic 105-key International"
+	"Kinesis Advantage"
+	"Kinesis Ergo Elan International"
+	"TypeMatrix 2030" ;
+keyboardLayoutFiles = $(keyboardLayoutFiles:G=keyboard-layout) ;
+SEARCH on $(keyboardLayoutFiles) = $(keyboardLayoutsDir) ;
+AddFilesToPackage data KeyboardLayouts
+	: $(keyboardLayoutFiles) ;
+
+# Add Apple Aluminum keyboard layout files to the image in an Apple Aluminum
+# subdirectory. The subdirectory is turned into a submenu in the Layout menu
+# of the Keymap preference app.
+local appleAluminumDir
+	= [ FDirName $(HAIKU_TOP) data system data KeyboardLayouts
+		Apple\ Aluminum ] ;
+local appleAluminumFiles =
+	"Apple Aluminium Extended International"
+	"Apple Aluminium International"
+	"Apple Aluminum (US)"
+	"Apple Aluminum Extended (US)" ;
+appleAluminumFiles = $(appleAluminumFiles:G=keyboard-layout) ;
+SEARCH on $(appleAluminumFiles) = $(appleAluminumDir) ;
+AddFilesToPackage data KeyboardLayouts Apple\ Aluminum
+	: $(appleAluminumFiles) ;
+
+# Add ThinkPad keyboard layout files to the image in a ThinkPad
+# subdirectory. The subdirectory is turned into a submenu in the Layout menu
+# of the Keymap preference app.
+local thinkpadDir
+	= [ FDirName $(HAIKU_TOP) data system data KeyboardLayouts ThinkPad ] ;
+local thinkPadFiles =
+	"ThinkPad (US)"
+	"ThinkPad International"
+	"ThinkPad T400s (US)"
+	"ThinkPad T400s International"
+	"ThinkPad X1 (US)"
+	"ThinkPad X1 International"
+	"ThinkPad X100e (US)"
+	"ThinkPad X100e International" ;
+thinkPadFiles = $(thinkPadFiles:G=keyboard-layout) ;
+SEARCH on $(thinkPadFiles) = $(thinkpadDir) ;
+AddFilesToPackage data KeyboardLayouts ThinkPad
+	: $(thinkPadFiles) ;
+
+# boot module links
+AddBootModuleSymlinksToPackage
+	acpi@x86 ata@ata pci isa@x86 config_manager dpc
+	ide@ide scsi usb
+	openpic@ppc
+	ata_adapter@ata ide_adapter@ide locked_pool scsi_periph
+	ahci generic_ide_pci it8211 legacy_sata silicon_image_3112
+	ide_isa@x86
+	<usb>uhci <usb>ohci <usb>ehci
+	scsi_cd scsi_disk usb_disk
+	virtio virtio_pci virtio_block virtio_scsi
+	efi_gpt
+	intel
+	bfs packagefs
+;
+
+# add-ons
+AddFilesToPackage add-ons accelerants	: $(SYSTEM_ADD_ONS_ACCELERANTS) ;
+AddFilesToPackage add-ons Translators	: $(SYSTEM_ADD_ONS_TRANSLATORS) ;
+AddFilesToPackage add-ons locale catalogs : $(SYSTEM_ADD_ONS_LOCALE_CATALOGS) ;
+
+AddFilesToPackage add-ons opengl :
+	x86 @{
+		Legacy\ Software\ Rasterizer@gcc2
+		Software\ Rasterizer@!gcc2
+	}@ # x86
+;
+
+AddFilesToPackage add-ons mail_daemon inbound_protocols		: POP3 IMAP ;
+AddFilesToPackage add-ons mail_daemon outbound_protocols 	: SMTP ;
+AddFilesToPackage add-ons mail_daemon inbound_filters
+	: MatchHeader SpamFilter NewMailNotification ;
+AddFilesToPackage add-ons mail_daemon outbound_filters		: Fortune ;
+
+AddFilesToPackage add-ons media : $(SYSTEM_ADD_ONS_MEDIA) ;
+AddFilesToPackage add-ons media plugins : $(SYSTEM_ADD_ONS_MEDIA_PLUGINS) ;
+
+AddFilesToPackage add-ons Tracker
+	: FileType Mark\ as… Mark\ as\ Read Open\ Target\ Folder
+		Open\ Terminal ZipOMatic ;
+AddSymlinkToPackage add-ons Tracker
+	: /boot/system/preferences/Backgrounds : Background ;
+AddSymlinkToPackage add-ons Tracker
+	: /boot/system/apps/TextSearch : TextSearch ;
+AddSymlinkToPackage add-ons Tracker
+	: /boot/system/apps/DiskUsage : DiskUsage ;
+
+AddFilesToPackage add-ons input_server devices
+	: <input>keyboard <input>mouse <input>tablet <input>wacom ;
+AddFilesToPackage add-ons input_server filters
+	: screen_saver shortcut_catcher ;
+
+AddFilesToPackage add-ons kernel network : <net>notifications stack ;
+AddFilesToPackage add-ons kernel network : dns_resolver ;
+AddFilesToPackage add-ons kernel network devices : $(SYSTEM_NETWORK_DEVICES) ;
+AddFilesToPackage add-ons kernel network datalink_protocols
+	: $(SYSTEM_NETWORK_DATALINK_PROTOCOLS) ;
+AddFilesToPackage add-ons kernel network ppp: $(SYSTEM_NETWORK_PPP) ;
+AddFilesToPackage add-ons kernel network protocols
+	: $(SYSTEM_NETWORK_PROTOCOLS) ;
+
+AddFilesToPackage add-ons Print : $(SYSTEM_ADD_ONS_PRINT) ;
+AddFilesToPackage add-ons Print transport
+	: $(SYSTEM_ADD_ONS_PRINT_TRANSPORT) ;
+AddFilesToPackage add-ons Screen\ Savers : $(SYSTEM_ADD_ONS_SCREENSAVERS) ;
+
+AddFilesToPackage add-ons disk_systems
+	: <disk_system>intel <disk_system>gpt <disk_system>bfs <disk_system>ntfs ;
+
+
+# the MIME DB
+CopyDirectoryToPackage data : <mimedb>mime_db : : : isTarget ;
+
+
+# Deskbar menu symlinks
+
+# "Applications" links
+DESKBAR_APPLICATIONS = ActivityMonitor CharacterMap CodyCam CDPlayer DeskCalc
+	Devices DiskProbe DriveSetup DiskUsage Expander HaikuDepot Icon-O-Matic
+	Installer Magnify Mail MediaConverter MediaPlayer MidiPlayer People PoorMan
+	Screenshot SoundRecorder StyledEdit Terminal TV
+;
+local linkTarget ;
+for linkTarget in $(DESKBAR_APPLICATIONS) {
+	AddSymlinkToPackage data deskbar menu Applications
+		: ../../../../apps/$(linkTarget) : $(linkTarget) ;
+}
+
+# "Desktop applets" links
+DESKBAR_DESKTOP_APPLETS = LaunchBox NetworkStatus PowerStatus ProcessController
+	Workspaces
+;
+for linkTarget in $(DESKBAR_DESKTOP_APPLETS) {
+	AddSymlinkToPackage data deskbar menu Desktop\ applets
+		: ../../../../apps/$(linkTarget) : $(linkTarget) ;
+}
+
+# "Preferences" links
+AddDirectoryToPackage data deskbar menu Preferences ;
+DESKBAR_PREFERENCES = $(SYSTEM_PREFERENCES:B) ;
+for linkTarget in $(DESKBAR_PREFERENCES) {
+	AddSymlinkToPackage data deskbar menu Preferences
+		: ../../../../preferences/$(linkTarget)
+		: $(linkTarget) ;
+}
+
+# "Demo" links
+AddDirectoryToPackage data deskbar menu Demos ;
+for linkTarget in $(SYSTEM_DEMOS) {
+	AddSymlinkToPackage data deskbar menu Demos
+		: ../../../../demos/$(linkTarget) : $(linkTarget) ;
+}
+
+# Deskbar menu entries file
+AddFilesToPackage data deskbar : <deskbar>menu_entries ;
+
+
+# optional
+# TODO: We should probably build another package (including the data files
+# above) that can be installed, if desired.
+AddFilesToPackage optional add-ons input_server methods : canna ;
+
+
+# PDF Writer enconding files
+CopyDirectoryToPackage data
+	: [ FDirName $(HAIKU_TOP) src add-ons print drivers pdf encoding ]
+	: "PDF Writer" : -x Jamfile ;
+
+# licenses
+CopyDirectoryToPackage data
+	: [ FDirName $(HAIKU_TOP) data system data licenses ]
+	: licenses ;
+
+# Copy documentation as per DiskUsage's license requirement.
+CopyDirectoryToPackage documentation
+	: [ FDirName $(HAIKU_TOP) docs apps diskusage ]
+	: diskusage ;
+
+# Copy documentation and sample programs as per PDFlib Lite's license
+# requirement.
+CopyDirectoryToPackage documentation
+	: [ FDirName $(HAIKU_TOP) src libs pdflib doc ]
+	: pdflib ;
+CopyDirectoryToPackage develop sample-code
+	: [ FDirName $(HAIKU_TOP) src libs pdflib bind pdflib ]
+	: pdflib ;
+
+
+BuildHaikuPackage $(haikuPackage) : haiku ;

build/jam/packages/HaikuBootstrap

@@ -0,0 +1,308 @@
+local architecture = $(HAIKU_PACKAGING_ARCHS[1]) ;
+
+
+local haikuPackage = haiku.hpkg ;
+HaikuPackage $(haikuPackage) ;
+
+
+# wifi firmware
+for driver in $(SYSTEM_ADD_ONS_DRIVERS_NET) {
+	local package = [ on $(driver) return $(HAIKU_WIFI_FIRMWARE_PACKAGE) ] ;
+	local archive = [ on $(driver) return $(HAIKU_WIFI_FIRMWARE_ARCHIVE) ] ;
+	local extract = [ on $(driver) return $(HAIKU_WIFI_FIRMWARE_DO_EXTRACT) ] ;
+	if $(archive) {
+		AddWifiFirmwareToPackage $(driver) : $(package) : $(archive)
+			: $(extract) ;
+	}
+	local packages = [ on $(driver) return $(HAIKU_WIFI_FIRMWARE_PACKAGES) ] ;
+	local archives = [ on $(driver) return $(HAIKU_WIFI_FIRMWARE_ARCHIVES) ] ;
+	for archive in $(archives) {
+		AddWifiFirmwareToPackage $(driver) : $(packages[1]) : $(archive)
+			: $(extract) ;
+		packages = $(packages[2-]) ;
+	}
+}
+
+
+# modules
+AddFilesToPackage add-ons kernel bus_managers : $(SYSTEM_ADD_ONS_BUS_MANAGERS) ;
+AddFilesToPackage add-ons kernel busses agp_gart : <agp_gart>intel@x86 ;
+
+if $(HAIKU_ATA_STACK) = 1 {
+	AddFilesToPackage add-ons kernel busses ata
+		: generic_ide_pci it8211 legacy_sata silicon_image_3112 ide_isa@x86 ;
+} else {
+	AddFilesToPackage add-ons kernel busses ide
+		: generic_ide_pci it8211 legacy_sata silicon_image_3112 ide_isa@x86 ;
+}
+
+AddFilesToPackage add-ons kernel busses scsi : ahci virtio_scsi ;
+AddFilesToPackage add-ons kernel busses usb : <usb>uhci <usb>ohci <usb>ehci ;
+AddFilesToPackage add-ons kernel busses virtio : virtio_pci ;
+AddFilesToPackage add-ons kernel console : vga_text ;
+AddFilesToPackage add-ons kernel debugger
+	: <kdebug>demangle <kdebug>disasm@x86 <kdebug>hangman
+	  <kdebug>invalidate_on_exit <kdebug>usb_keyboard <kdebug>qrencode
+	  <kdebug>run_on_exit ;
+AddFilesToPackage add-ons kernel file_systems : $(SYSTEM_ADD_ONS_FILE_SYSTEMS) ;
+AddFilesToPackage add-ons kernel generic
+	: ata_adapter@ata bios@x86,x86_64 dpc ide_adapter@ide
+		locked_pool mpu401 scsi_periph <module>tty ;
+AddFilesToPackage add-ons kernel partitioning_systems
+	: amiga_rdb apple efi_gpt intel session ;
+AddFilesToPackage add-ons kernel interrupt_controllers : openpic@ppc ;
+
+if $(TARGET_ARCH) = x86 || $(TARGET_ARCH) = x86_64 {
+	AddFilesToPackage add-ons kernel cpu : generic_x86 ;
+}
+
+# drivers
+AddNewDriversToPackage disk scsi	: scsi_cd scsi_disk ;
+AddNewDriversToPackage disk virtual : virtio_block ;
+AddNewDriversToPackage power		: enhanced_speedstep@x86 ;
+AddNewDriversToPackage power		: acpi_battery@x86 ;
+#AddNewDriversToPackage display		: display_controls@x86 ;
+
+# legacy drivers
+AddDriversToPackage					: console dprintf null random <driver>tty
+										zero ;
+AddDriversToPackage audio hmulti	: $(SYSTEM_ADD_ONS_DRIVERS_AUDIO) ;
+AddDriversToPackage audio old		: $(SYSTEM_ADD_ONS_DRIVERS_AUDIO_OLD) ;
+AddDriversToPackage midi			: $(SYSTEM_ADD_ONS_DRIVERS_MIDI) ;
+AddDriversToPackage bus				: usb_raw fw_raw@x86 ;
+AddDriversToPackage disk floppy		: pc_floppy@x86 ;
+AddDriversToPackage disk usb		: usb_disk ;
+AddDriversToPackage disk usb		: usb_floppy ;
+AddDriversToPackage printer usb		: usb_printer ;
+AddDriversToPackage disk virtual	: nbd ;
+AddDriversToPackage graphics		: $(SYSTEM_ADD_ONS_DRIVERS_GRAPHICS) ;
+AddDriversToPackage input			: ps2_hid usb_hid wacom ;
+AddDriversToPackage misc			: <driver>poke <driver>mem ;
+AddDriversToPackage net				: $(SYSTEM_ADD_ONS_DRIVERS_NET) ;
+AddDriversToPackage ports			: usb_serial ;
+AddDriversToPackage power			: $(SYSTEM_ADD_ONS_DRIVERS_POWER) ;
+
+# kernel
+AddFilesToPackage : <revisioned>kernel_$(TARGET_ARCH) ;
+
+# libs
+AddLibrariesToPackage lib
+	: [ HaikuImageGetSystemLibs ] [ HaikuImageGetPrivateSystemLibs ] ;
+
+# libnetwork.so replaces quite a few libraries
+if $(HAIKU_GCC_VERSION_$(architecture)[1]) = 2 {
+	local libNetworkAliases = libsocket.so libbind.so libnet.so ;
+	local lib ;
+	for lib in $(libNetworkAliases) {
+		AddSymlinkToPackage lib : libnetwork.so : $(lib) ;
+	}
+
+	AddSymlinkToPackage lib : libbnetapi.so : libnetapi.so ;
+}
+
+
+# servers
+AddFilesToPackage servers : $(SYSTEM_SERVERS) ;
+
+# apps
+AddFilesToPackage  				: runtime_loader Deskbar Tracker ;
+AddFilesToPackage bin			: $(SYSTEM_BIN) consoled ;
+AddFilesToPackage apps			: $(SYSTEM_APPS) ;
+AddFilesToPackage preferences	: $(SYSTEM_PREFERENCES) ;
+AddFilesToPackage demos			: $(SYSTEM_DEMOS) ;
+
+SEARCH on which = [ FDirName $(HAIKU_TOP) data bin ] ;
+AddFilesToPackage bin : which ;
+SEARCH on install-wifi-firmwares.sh = [ FDirName $(HAIKU_TOP) data bin ] ;
+AddFilesToPackage bin : install-wifi-firmwares.sh ;
+
+AddSymlinkToPackage bin : bash : sh ;
+AddSymlinkToPackage bin : trash : untrash ;
+AddSymlinkToPackage bin : less : more ;
+AddSymlinkToPackage bin : gzip : gunzip ;
+AddSymlinkToPackage bin : gzip : zcat ;
+AddSymlinkToPackage bin : zdiff : zcmp ;
+AddSymlinkToPackage bin : unzip : zipinfo ;
+AddSymlinkToPackage bin : gawk : awk ;
+
+# scripts and data files
+local bootScripts = Bootscript Bootscript.cd SetupEnvironment Netscript
+	InstallerInitScript InstallerFinishScript ;
+SEARCH on $(bootScripts) = [ FDirName $(HAIKU_TOP) data system boot ] ;
+AddFilesToPackage boot : $(bootScripts) ;
+
+# post install scripts
+local postInstallFiles = default_deskbar_items.sh ;
+postInstallFiles = $(postInstallFiles:G=post-install) ;
+SEARCH on $(postInstallFiles)
+	= [ FDirName $(HAIKU_TOP) data common boot post_install ] ;
+AddFilesToPackage boot post-install : $(postInstallFiles) ;
+
+local fortuneFiles = [ Glob $(HAIKU_TOP)/data/system/data/fortunes
+	: [a-zA-Z0-9]* ] ;
+fortuneFiles = $(fortuneFiles:G=data!fortunes) ;
+AddFilesToPackage data fortunes : $(fortuneFiles) ;
+
+local fontDir = [ FDirName $(HAIKU_TOP) data system data fonts ] ;
+local psFonts = [ Glob $(fontDir)/psfonts : *.afm *.pfb ] ;
+local ttFonts = [ Glob $(fontDir)/ttfonts : *.ttf ] ;
+AddFilesToPackage data fonts psfonts : $(psFonts) ;
+AddFilesToPackage data fonts ttfonts : $(ttFonts) ;
+
+local keymapFiles = [ Glob [ FDirName $(HAIKU_TOP) src data keymaps ]
+	: *.keymap ] ;
+keymapFiles = $(keymapFiles:BG=keymap) ;
+AddFilesToPackage data Keymaps : $(keymapFiles) ;
+AddSymlinkToPackage data Keymaps : Swedish : Finnish ;
+AddSymlinkToPackage data Keymaps : Slovene : Croatian ;
+AddSymlinkToPackage data Keymaps : US-International : Brazilian ;
+
+# Copy keyboard layout files to the image one-by-one.
+local keyboardLayoutsDir
+	= [ FDirName $(HAIKU_TOP) data system data KeyboardLayouts ] ;
+local keyboardLayoutFiles =
+	"Generic 104-key"
+	"Generic 105-key International"
+	"Kinesis Advantage"
+	"Kinesis Ergo Elan International"
+	"TypeMatrix 2030" ;
+keyboardLayoutFiles = $(keyboardLayoutFiles:G=keyboard-layout) ;
+SEARCH on $(keyboardLayoutFiles) = $(keyboardLayoutsDir) ;
+AddFilesToPackage data KeyboardLayouts
+	: $(keyboardLayoutFiles) ;
+
+# Add Apple Aluminum keyboard layout files to the image in an Apple Aluminum
+# subdirectory. The subdirectory is turned into a submenu in the Layout menu
+# of the Keymap preference app.
+local appleAluminumDir
+	= [ FDirName $(HAIKU_TOP) data system data KeyboardLayouts
+		Apple\ Aluminum ] ;
+local appleAluminumFiles =
+	"Apple Aluminium Extended International"
+	"Apple Aluminium International"
+	"Apple Aluminum (US)"
+	"Apple Aluminum Extended (US)" ;
+appleAluminumFiles = $(appleAluminumFiles:G=keyboard-layout) ;
+SEARCH on $(appleAluminumFiles) = $(appleAluminumDir) ;
+AddFilesToPackage data KeyboardLayouts Apple\ Aluminum
+	: $(appleAluminumFiles) ;
+
+# Add ThinkPad keyboard layout files to the image in a ThinkPad
+# subdirectory. The subdirectory is turned into a submenu in the Layout menu
+# of the Keymap preference app.
+local thinkpadDir
+	= [ FDirName $(HAIKU_TOP) data system data KeyboardLayouts ThinkPad ] ;
+local thinkPadFiles =
+	"ThinkPad (US)"
+	"ThinkPad International"
+	"ThinkPad T400s (US)"
+	"ThinkPad T400s International"
+	"ThinkPad X1 (US)"
+	"ThinkPad X1 International"
+	"ThinkPad X100e (US)"
+	"ThinkPad X100e International" ;
+thinkPadFiles = $(thinkPadFiles:G=keyboard-layout) ;
+SEARCH on $(thinkPadFiles) = $(thinkpadDir) ;
+AddFilesToPackage data KeyboardLayouts ThinkPad
+	: $(thinkPadFiles) ;
+
+# boot module links
+AddBootModuleSymlinksToPackage
+	acpi@x86 ata@ata pci isa@x86 config_manager dpc
+	ide@ide scsi usb
+	openpic@ppc
+	ata_adapter@ata ide_adapter@ide locked_pool scsi_periph
+	ahci generic_ide_pci it8211 legacy_sata silicon_image_3112
+	ide_isa@x86
+	<usb>uhci <usb>ohci <usb>ehci
+	scsi_cd scsi_disk usb_disk
+	virtio virtio_pci virtio_block virtio_scsi
+	efi_gpt
+	intel
+	bfs packagefs
+;
+
+# add-ons
+AddFilesToPackage add-ons accelerants	: $(SYSTEM_ADD_ONS_ACCELERANTS) ;
+AddFilesToPackage add-ons Translators	: $(SYSTEM_ADD_ONS_TRANSLATORS) ;
+AddFilesToPackage add-ons locale catalogs : $(SYSTEM_ADD_ONS_LOCALE_CATALOGS) ;
+
+AddFilesToPackage add-ons Tracker
+	: FileType-F Mark\ as… Mark\ as\ Read-R Open\ Target\ Folder-O
+		Open\ Terminal-T ZipOMatic-Z ;
+AddSymlinkToPackage add-ons Tracker
+	: /boot/system/preferences/Backgrounds : Background-B ;
+AddSymlinkToPackage add-ons Tracker
+	: /boot/system/apps/TextSearch : TextSearch-G ;
+AddSymlinkToPackage add-ons Tracker
+	: /boot/system/apps/DiskUsage : DiskUsage-I ;
+
+AddFilesToPackage add-ons input_server devices
+	: <input>keyboard <input>mouse <input>tablet <input>wacom ;
+AddFilesToPackage add-ons input_server filters
+	: screen_saver shortcut_catcher ;
+
+AddFilesToPackage add-ons kernel network : <net>notifications stack ;
+AddFilesToPackage add-ons kernel network : dns_resolver ;
+AddFilesToPackage add-ons kernel network devices : $(SYSTEM_NETWORK_DEVICES) ;
+AddFilesToPackage add-ons kernel network datalink_protocols
+	: $(SYSTEM_NETWORK_DATALINK_PROTOCOLS) ;
+AddFilesToPackage add-ons kernel network ppp: $(SYSTEM_NETWORK_PPP) ;
+AddFilesToPackage add-ons kernel network protocols
+	: $(SYSTEM_NETWORK_PROTOCOLS) ;
+
+AddFilesToPackage add-ons disk_systems
+	: <disk_system>intel <disk_system>gpt <disk_system>bfs <disk_system>ntfs ;
+
+
+# the MIME DB
+CopyDirectoryToPackage data : <mimedb>mime_db : : : isTarget ;
+
+
+# Deskbar menu symlinks
+
+# "Applications" links
+DESKBAR_APPLICATIONS = ActivityMonitor CharacterMap DeskCalc
+	Devices DiskProbe DriveSetup DiskUsage Expander Installer
+	StyledEdit Terminal
+;
+local linkTarget ;
+for linkTarget in $(DESKBAR_APPLICATIONS) {
+	AddSymlinkToPackage data deskbar menu Applications
+		: ../../../../apps/$(linkTarget) : $(linkTarget) ;
+}
+
+# "Desktop applets" links
+DESKBAR_DESKTOP_APPLETS = LaunchBox NetworkStatus PowerStatus ProcessController
+	Workspaces
+;
+for linkTarget in $(DESKBAR_DESKTOP_APPLETS) {
+	AddSymlinkToPackage data deskbar menu Desktop\ applets
+		: ../../../../apps/$(linkTarget) : $(linkTarget) ;
+}
+
+# "Preferences" links
+AddDirectoryToPackage data deskbar menu Preferences ;
+DESKBAR_PREFERENCES = $(SYSTEM_PREFERENCES:B) ;
+for linkTarget in $(DESKBAR_PREFERENCES) {
+	AddSymlinkToPackage data deskbar menu Preferences
+		: ../../../../preferences/$(linkTarget)
+		: $(linkTarget) ;
+}
+
+# Deskbar menu entries file
+AddFilesToPackage data deskbar : <deskbar>menu_entries ;
+
+
+# licenses
+CopyDirectoryToPackage data
+	: [ FDirName $(HAIKU_TOP) data system data licenses ]
+	: licenses ;
+
+# Copy documentation as per DiskUsage's license requirement.
+CopyDirectoryToPackage documentation
+	: [ FDirName $(HAIKU_TOP) docs apps diskusage ]
+	: diskusage ;
+
+
+BuildHaikuPackage $(haikuPackage) : haiku ;

build/jam/packages/HaikuCrossDevel

@@ -0,0 +1,102 @@
+# This package is like the HaikuDevel package, but it is meant for cross
+# development, i.e. it assumes that a specific cross compiler is installed
+# on the Haiku system where this package is being used.
+# The main use of this package is to provide HaikuPorter with a development
+# environment for a cross-build Haiku platform.
+
+local primaryArchitecture = $(HAIKU_PACKAGING_ARCHS[1]) ;
+local architecture = $(TARGET_PACKAGING_ARCH) ;
+local isPrimaryArchitecture = [ MultiArchIfPrimary 1 : ] ;
+
+local packageNameSuffix = $(primaryArchitecture) ;
+local architectureSubDir ;
+if ! $(isPrimaryArchitecture) {
+	packageNameSuffix = $(primaryArchitecture)_$(architecture) ;
+	architectureSubDir = $(architecture) ;
+}
+
+local additionalLibraries_stage1 ;
+local additionalLibraries
+	= [ MultiArchDefaultGristFiles libbe.so libnetwork.so libpackage.so ] ;
+
+local stage ;
+for stage in _stage1 "" {
+	# first create the actual cross development package
+
+	local haikuCrossDevelSysrootPackage
+		= haiku_cross_devel_sysroot$(stage)_$(packageNameSuffix).hpkg ;
+	HaikuPackage $(haikuCrossDevelSysrootPackage) ;
+
+	local developCrossLibDirTokens = develop lib $(architectureSubDir) ;
+
+	# glue code
+	AddFilesToPackage $(developCrossLibDirTokens) :
+		<src!system!glue!arch!$(TARGET_ARCH)!$(architecture)>crti.o
+		<src!system!glue!arch!$(TARGET_ARCH)!$(architecture)>crtn.o
+		<src!system!glue!$(architecture)>init_term_dyn.o
+		<src!system!glue!$(architecture)>start_dyn.o
+		<src!system!glue!$(architecture)>haiku_version_glue.o
+		;
+
+	# kernel
+	if $(isPrimaryArchitecture) {
+		AddFilesToPackage $(developCrossLibDirTokens) : kernel.so : _KERNEL_ ;
+	}
+
+	# libraries
+	AddLibrariesToPackage $(developCrossLibDirTokens) :
+		[ MultiArchDefaultGristFiles libbsd.so ]
+		[ MultiArchDefaultGristFiles libroot.so : revisioned ]
+		$(HAIKU_SHARED_LIBSTDC++_$(architecture))
+		$(HAIKU_SHARED_LIBSUPC++_$(architecture))
+		$(additionalLibraries$(stage))
+		;
+
+	# static libraries
+	AddFilesToPackage $(developCrossLibDirTokens)
+		: <$(architecture)>liblocalestub.a ;
+
+	# the POSIX error code mapper library
+	AddFilesToPackage $(developCrossLibDirTokens)
+		: [ MultiArchDefaultGristFiles libposix_error_mapper.a ] ;
+
+	# headers
+	local developCrossHeadersDirTokens = develop headers ;
+	local headerDir ;
+	for headerDir in config glibc os posix {
+		CopyDirectoryToPackage $(developCrossHeadersDirTokens)
+			: [ FDirName $(HAIKU_TOP) headers $(headerDir) ] ;
+	}
+
+	# BSD and GNU compatibility headers
+	for headerDir in bsd gnu {
+		CopyDirectoryToPackage $(developCrossHeadersDirTokens)
+			: [ FDirName $(HAIKU_TOP) headers compatibility $(headerDir) ] ;
+	}
+
+	# cpp headers
+	if $(HAIKU_GCC_VERSION_$(architecture)[1]) = 2 {
+		# GCC 2 only -- for GCC 4 they come with the DevelopmentBase package
+		CopyDirectoryToPackage $(developCrossHeadersDirTokens) c++
+			: [ FDirName $(HAIKU_TOP) headers cpp ] : 2.95.3 ;
+	}
+
+	BuildHaikuPackage $(haikuCrossDevelSysrootPackage)
+		: haiku_cross_devel_sysroot ;
+
+	# Now create a wrapper package which just contains the actual cross
+	# development package. This wrapper package can safely be installed into the
+	# system hierarchy of the target system, from where haikuporter will fetch
+	# it when needed.
+
+	local haikuCrossDevelPackage
+		= haiku_cross_devel$(stage)_$(packageNameSuffix).hpkg ;
+	HaikuPackage $(haikuCrossDevelPackage) ;
+
+	# add the wrapped package
+	local developCrossDirTokens = develop cross ;
+	AddFilesToPackage $(developCrossDirTokens)
+		: $(haikuCrossDevelSysrootPackage) ;
+
+	BuildHaikuPackage $(haikuCrossDevelPackage) : haiku_cross_devel ;
+}

build/jam/packages/HaikuDevel

@@ -0,0 +1,94 @@
+local architecture = $(HAIKU_PACKAGING_ARCHS[1]) ;
+
+
+local haikuDevelPackage = haiku_devel.hpkg ;
+HaikuPackage $(haikuDevelPackage) ;
+
+local arch = $(TARGET_ARCH) ;
+
+# glue code
+AddFilesToPackage develop lib :
+	<src!system!glue!arch!$(arch)!$(architecture)>crti.o
+	<src!system!glue!arch!$(arch)!$(architecture)>crtn.o
+	<src!system!glue!$(architecture)>init_term_dyn.o
+	<src!system!glue!$(architecture)>start_dyn.o
+	<src!system!glue!$(architecture)>haiku_version_glue.o
+	;
+
+# kernel
+AddFilesToPackage develop lib : kernel.so : _KERNEL_ ;
+
+# additional libraries
+local developmentLibs = <revisioned>libroot_debug.so ;
+AddFilesToPackage lib : $(developmentLibs) ;
+
+# library symlinks
+local lib ;
+for lib in [ HaikuImageGetSystemLibs ] $(developmentLibs) {
+	AddSymlinkToPackage develop lib : /system/lib $(lib:BS) ;
+	local abiVersion = [ on $(lib) return $(HAIKU_LIB_ABI_VERSION) ] ;
+	if $(abiVersion) {
+		local abiVersionedLib = $(lib:BS).$(abiVersion) ;
+		AddSymlinkToPackage develop lib
+			: /system/lib $(abiVersionedLib) ;
+	}
+}
+
+# static libraries
+AddFilesToPackage develop lib : <$(architecture)>liblocalestub.a ;
+
+# the POSIX error code mapper library
+AddFilesToPackage develop lib : libposix_error_mapper.a ;
+
+# ABI independent stuff
+
+# headers
+AddHeaderDirectoryToPackage config ;
+AddHeaderDirectoryToPackage glibc ;
+AddHeaderDirectoryToPackage os ;
+AddHeaderDirectoryToPackage posix ;
+
+# private headers
+AddHeaderDirectoryToPackage private ;
+CopyDirectoryToPackage develop headers private libs compat
+	: [ FDirName $(HAIKU_TOP) src libs compat freebsd_network ]
+	: : -x *.c -x *.cpp -x *.awk -x Jamfile -x miidevs ;
+CopyDirectoryToPackage develop headers private libs compat
+	: [ FDirName $(HAIKU_TOP) src libs compat freebsd_wlan ]
+	: : -x *.c -x Jamfile ;
+
+# create be -> os symlink for now
+AddSymlinkToPackage develop headers : os : be ;
+
+# BSD and GNU compatibility headers
+AddHeaderDirectoryToPackage compatibility bsd : bsd ;
+AddHeaderDirectoryToPackage compatibility gnu : gnu ;
+
+# third party libs headers
+if ! $(HAIKU_BOOTSTRAP_BUILD) {
+	AddHeaderDirectoryToPackage libs tiff : 3rdparty ;
+}
+
+# cpp headers
+if $(HAIKU_GCC_VERSION_$(architecture)[1]) = 2 {
+	# GCC 2 only -- for GCC 4 they come with the gcc package
+	CopyDirectoryToPackage develop headers c++
+		: [ FDirName $(HAIKU_TOP) headers cpp ] : 2.95.3 ;
+}
+
+# OpenGL headers
+if $(TARGET_ARCH) = x86 && ! $(HAIKU_BOOTSTRAP_BUILD) {
+	local mesaGlHeaders
+		= [ FDirName [ BuildFeatureAttribute mesa : headers : path ] GL ] ;
+	local mesaGlHeadersDependency = [ BuildFeatureAttribute mesa : headers ] ;
+	mesaGlHeaders = $(mesaGlHeaders:G=$(mesaGlHeadersDependency:G)) ;
+	Depends $(mesaGlHeaders) : $(mesaGlHeadersDependency) ;
+	CopyDirectoryToPackage develop headers os opengl
+		: $(mesaGlHeaders) : : : isTarget ;
+}
+
+# Deskbar menu symlinks
+AddSymlinkToPackage data deskbar menu Applications
+	: ../../../../apps/Debugger : Debugger ;
+
+BuildHaikuPackage $(haikuDevelPackage) : haiku_devel ;

build/jam/packages/HaikuDevelSecondary

@@ -0,0 +1,64 @@
+local architecture = $(TARGET_PACKAGING_ARCH) ;
+
+
+local haikuDevelPackage = haiku_$(architecture)_devel.hpkg ;
+HaikuPackage $(haikuDevelPackage) ;
+
+local arch = $(TARGET_ARCH) ;
+
+# glue code
+AddFilesToPackage develop lib $(architecture) :
+	<src!system!glue!arch!$(arch)!$(architecture)>crti.o
+	<src!system!glue!arch!$(arch)!$(architecture)>crtn.o
+	<src!system!glue!$(architecture)>init_term_dyn.o
+	<src!system!glue!$(architecture)>start_dyn.o
+	<src!system!glue!$(architecture)>haiku_version_glue.o
+	;
+
+# additional libraries
+local developmentLibs = <revisioned>libroot_debug.so ;
+AddFilesToPackage lib : $(developmentLibs) ;
+
+# library symlinks
+local lib ;
+for lib in [ HaikuImageGetSystemLibs ] $(developmentLibs) {
+	AddSymlinkToPackage develop lib $(architecture)
+		: /system/lib/$(architecture) $(lib:BS) ;
+	local abiVersion = [ on $(lib) return $(HAIKU_LIB_ABI_VERSION) ] ;
+	if $(abiVersion) {
+		local abiVersionedLib = $(lib:BS).$(abiVersion) ;
+		AddSymlinkToPackage develop lib $(architecture)
+			: /system/lib/$(architecture) $(abiVersionedLib) ;
+	}
+}
+
+# static libraries
+AddFilesToPackage develop lib $(architecture)
+	: <$(architecture)>liblocalestub.a ;
+
+# the POSIX error code mapper library
+AddFilesToPackage develop lib $(architecture)
+	: libposix_error_mapper.a ;
+
+# ABI independent stuff
+
+# cpp headers
+if $(HAIKU_GCC_VERSION_$(architecture)[1]) = 2 {
+	# GCC 2 only -- for GCC 4 they come with the gcc package
+	CopyDirectoryToPackage develop headers c++
+		: [ FDirName $(HAIKU_TOP) headers cpp ] : 2.95.3 ;
+}
+
+# OpenGL headers
+if $(TARGET_ARCH) = x86 && ! $(HAIKU_BOOTSTRAP_BUILD) {
+	local mesaGlHeaders
+		= [ FDirName [ BuildFeatureAttribute mesa : headers : path ] GL ] ;
+	local mesaGlHeadersDependency = [ BuildFeatureAttribute mesa : headers ] ;
+	mesaGlHeaders = $(mesaGlHeaders:G=$(mesaGlHeadersDependency:G)) ;
+	Depends $(mesaGlHeaders) : $(mesaGlHeadersDependency) ;
+	CopyDirectoryToPackage develop headers $(architecture) os opengl
+		: $(mesaGlHeaders) : : : isTarget ;
+}
+
+
+BuildHaikuPackage $(haikuDevelPackage) : haiku_devel_secondary ;

build/jam/packages/HaikuLoader

@@ -0,0 +1,13 @@
+local haikuLoaderPackage = haiku_loader.hpkg ;
+HaikuPackage $(haikuLoaderPackage) ;
+
+
+# boot loader
+AddFilesToPackage : haiku_loader ;
+
+
+# Force no compression, so the stage one loader can directly execute the boot
+# loader.
+HAIKU_PACKAGE_COMPRESSION_LEVEL on $(haikuLoaderPackage) = 0 ;
+
+BuildHaikuPackage $(haikuLoaderPackage) : haiku_loader ;

build/jam/packages/HaikuSecondary

@@ -0,0 +1,49 @@
+local architecture = $(TARGET_PACKAGING_ARCH) ;
+
+
+local haikuPackage = haiku_$(architecture).hpkg ;
+HaikuPackage $(haikuPackage) ;
+
+
+# libs
+AddLibrariesToPackage lib $(architecture)
+	: [ HaikuImageGetSystemLibs ] [ HaikuImageGetPrivateSystemLibs ] ;
+
+# libnetwork.so replaces quite a few libraries
+if $(HAIKU_GCC_VERSION_$(architecture)[1]) = 2 {
+	local libNetworkAliases = libsocket.so libbind.so libnet.so ;
+	local lib ;
+	for lib in $(libNetworkAliases) {
+		AddSymlinkToPackage lib $(architecture) : libnetwork.so : $(lib) ;
+	}
+
+	AddSymlinkToPackage lib $(architecture) : libbnetapi.so : libnetapi.so ;
+}
+
+
+# # add-ons
+# local addOnsDir = add-ons $(architecture) ;
+#
+# AddFilesToPackage $(addOnsDir) accelerants
+# 	: $(SYSTEM_ADD_ONS_ACCELERANTS) ;
+# AddFilesToPackage $(addOnsDir) Translators
+# 	: $(SYSTEM_ADD_ONS_TRANSLATORS) ;
+# AddFilesToPackage $(addOnsDir) locale catalogs
+# 	: $(SYSTEM_ADD_ONS_LOCALE_CATALOGS) ;
+#
+# AddFilesToPackage $(addOnsDir) opengl :
+# 	x86 @{
+# 		Legacy\ Software\ Rasterizer@gcc2
+# 		Software\ Rasterizer@!gcc2
+# 	}@ # x86
+# ;
+#
+# AddFilesToPackage $(addOnsDir) media : $(SYSTEM_ADD_ONS_MEDIA) ;
+# AddFilesToPackage $(addOnsDir) media plugins
+# 	: $(SYSTEM_ADD_ONS_MEDIA_PLUGINS) ;
+#
+# AddFilesToPackage $(addOnsDir) disk_systems
+# 	: <disk_system>intel <disk_system>gpt <disk_system>bfs <disk_system>ntfs ;
+
+
+BuildHaikuPackage $(haikuPackage) : haiku_secondary ;

build/jam/packages/HaikuSecondaryBootstrap

@@ -0,0 +1,24 @@
+local architecture = $(TARGET_PACKAGING_ARCH) ;
+
+
+local haikuPackage = haiku_$(architecture).hpkg ;
+HaikuPackage $(haikuPackage) ;
+
+
+# libs
+AddLibrariesToPackage lib $(architecture)
+	: [ HaikuImageGetSystemLibs ] [ HaikuImageGetPrivateSystemLibs ] ;
+
+# libnetwork.so replaces quite a few libraries
+if $(HAIKU_GCC_VERSION_$(architecture)[1]) = 2 {
+	local libNetworkAliases = libsocket.so libbind.so libnet.so ;
+	local lib ;
+	for lib in $(libNetworkAliases) {
+		AddSymlinkToPackage lib $(architecture) : libnetwork.so : $(lib) ;
+	}
+
+	AddSymlinkToPackage lib $(architecture) : libbnetapi.so : libnetapi.so ;
+}
+
+
+BuildHaikuPackage $(haikuPackage) : haiku_secondary ;

build/jam/packages/HaikuUserguide

@@ -0,0 +1,9 @@
+local haikuUserGuidePackage = haiku_userguide.hpkg ;
+HaikuPackage $(haikuUserGuidePackage) ;
+
+CopyDirectoryToPackage documentation : [ FDirName $(HAIKU_TOP) docs userguide ]
+	: userguide ;
+SEARCH on userguide = [ FDirName $(HAIKU_TOP) data bin ] ;
+AddFilesToPackage bin : userguide ;
+
+BuildHaikuPackage $(haikuUserGuidePackage) : haiku_userguide ;

build/jam/packages/HaikuWelcome

@@ -0,0 +1,9 @@
+local haikuWelcomePackage = haiku_welcome.hpkg ;
+HaikuPackage $(haikuWelcomePackage) ;
+
+CopyDirectoryToPackage documentation : [ FDirName $(HAIKU_TOP) docs welcome ]
+	: welcome ;
+SEARCH on welcome = [ FDirName $(HAIKU_TOP) data bin ] ;
+AddFilesToPackage bin : welcome ;
+
+BuildHaikuPackage $(haikuWelcomePackage) : haiku_welcome ;

build/jam/packages/MakefileEngine

@@ -0,0 +1,12 @@
+local makefileEnginePackage = makefile_engine.hpkg ;
+HaikuPackage $(makefileEnginePackage) ;
+
+# skeleton makefile and makefile-engine
+local makefileEngineFiles =
+	<makefile-engine>makefile
+	<makefile-engine>makefile-engine
+;
+SEARCH on $(makefileEngineFiles) = [ FDirName $(HAIKU_TOP) data develop ] ;
+AddFilesToPackage develop etc : $(makefileEngineFiles) ;
+
+BuildHaikuPackage $(makefileEnginePackage) : makefile_engine ;

build/jam/packages/WebPositive

@@ -0,0 +1,11 @@
+if [ FIsBuildFeatureEnabled webpositive ] {
+	local architecture = $(TARGET_PACKAGING_ARCH) ;
+	local webpositivePackage = webpositive.hpkg ;
+	HaikuPackage $(webpositivePackage) ;
+
+	AddFilesToPackage apps : WebPositive ;
+	AddSymlinkToPackage data deskbar menu Applications
+		: ../../../../apps/WebPositive : WebPositive ;
+
+	BuildHaikuPackage $(webpositivePackage) : webpositive ;
+}

build/jam/repositories/HaikuPorts/x86

@@ -0,0 +1,251 @@
+RemotePackageRepository HaikuPorts
+	: x86
+	: http://haiku-files.org/files/repo
+	:
+	# architecture "any" packages
+	be_book-2008_10_26-1
+	ca_root_certificates-2012_12_29-1
+	texi2html-1.82-2
+	timgmsoundfont-2004_01_24-3
+	wqy_microhei-0.2.0~beta-3
+	:
+	# repository architecture packages
+	# primary architecture (x86)
+	apr-1.4.6-7
+	apr_devel-1.4.6-7
+	apr_util-1.4.1-4
+	apr_util_devel-1.4.1-4
+	autoconf-2.69-4
+	automake-1.13.1-4
+#	bepdf-1.1.1~beta5_2013_04_28-1
+	binutils-2.23.2_2013_04_09-1
+	bison-2.4.3-5
+	bzip2-1.0.6-3
+	cdrtools-3.01~a07-3
+	cmake-2.8.5-6
+	ctags-5.8-3
+	curl-7.26.0-5
+	curl_devel-7.26.0-5
+	cvs-1.12.13.1-5
+	doxygen-1.6.3-4
+	expat-2.0.1-7
+	expat_devel-2.0.1-7
+	ffmpeg-0.10.2-4
+	ffmpeg_devel-0.10.2-4
+	flex-2.5.35-6
+	freetype-2.4.9-3
+	freetype_devel-2.4.9-3
+	gcc-4.7.3_2013_08_12-2
+	gettext-0.18.1.1-5
+	gettext_libintl-0.18.1.1-5
+	git-1.8.3.4-1
+	git_arch-1.8.3.4-1
+	git_cvs-1.8.3.4-1
+	git_daemon-1.8.3.4-1
+	git_email-1.8.3.4-1
+	git_svn-1.8.3.4-1
+	glu-9.0.0-2
+	glu_devel-9.0.0-2
+	gperf-3.0.4-1
+	grep-2.14-5
+	groff-1.20.1-2
+	haikuwebkit-1.1.3_2013_08_09-2
+	haikuwebkit_devel-1.1.3_2013_08_09-2
+	htmldoc-1.8.27-3
+	icu-4.8.1.1-4
+	icu_devel-4.8.1.1-4
+	jam-2.5_2012_10_12-1
+	jpeg-9-3
+	jpeg_devel-9-3
+	jpeg_tools-9-3
+	keymapswitcher-1.2.7.10-1
+	libedit-2012_06_01_3.0-1
+	libedit_devel-2012_06_01_3.0-1
+	libiconv-1.13.1-6
+	libiconv_devel-1.13.1-6
+	libogg-1.3.0-2
+	libogg_devel-1.3.0-2
+	libpcre-8.21-5
+	libpng-1.5.12-3
+	libpng_devel-1.5.12-3
+	libsolv-0.3.0_haiku_2013_06_16-2
+	libsolv_devel-0.3.0_haiku_2013_06_16-2
+	libtheora-1.1.1-2
+	libtheora_devel-1.1.1-2
+	libtool-2.4-8
+	libtool_libltdl-2.4-8
+	libvorbis-1.3.2-2
+	libvorbis_devel-1.3.2-2
+	libvpx-1.0.0-2
+	libvpx_devel-1.0.0-2
+	libxml2-2.8.0-5
+	libxml2_devel-2.8.0-5
+	libxml2_python-2.8.0-5
+	m4-1.4.16-5
+	make-3.82-5
+	man-1.6g-2
+	mercurial-2.2.2-3
+	mesa-9.1.1-1
+	mesa_devel-9.1.1-1
+	mkdepend-1.7-3
+	nano-2.2.6-3
+	ncurses-5.9-10
+	ncurses_devel-5.9-10
+	neon-0.29.6-7
+	neon_devel-0.29.6-7
+	openssh-6.0p1-8
+	openssl-1.0.0j-3
+	openssl_devel-1.0.0j-3
+	p7zip-9.20.1-4
+	pe-2.4.3_hg602-5
+	perl-5.10.1-6
+	pkgconfig-0.27.1-1
+	python-2.6.8-5
+	readline-6.2-3
+	scons-2.2.0-1
+	sed-4.2.1-6
+	speex-1.2~rc1-2
+	speex_devel-1.2~rc1-2
+	sqlite-3.7.13-4
+	sqlite_devel-3.7.13-4
+	subversion-1.6.18-6
+	subversion_devel-1.6.18-6
+	tar-1.26-6
+	texinfo-4.13a-7
+	vision-0.9.7.r944-1
+	wpa_supplicant-2.0-3
+	xz_utils-5.0.4-1
+	yasm-1.2.0-3
+	zlib-1.2.8-3
+	zlib_devel-1.2.8-3
+
+	# secondary architecture (x86_gcc2)
+	binutils_x86_gcc2-2.17_2013_04_21-2
+	curl_x86_gcc2-7.26.0-5
+	curl_x86_gcc2_devel-7.26.0-5
+	expat_x86_gcc2-2.0.1-7
+	expat_x86_gcc2_devel-2.0.1-7
+	ffmpeg_x86_gcc2-0.10.2-4
+	ffmpeg_x86_gcc2_devel-0.10.2-4
+	freetype_x86_gcc2-2.4.9-3
+	freetype_x86_gcc2_devel-2.4.9-3
+	gcc_x86_gcc2-2.95.3_2013_08_15-2
+	gettext_x86_gcc2-0.18.1.1-5
+	gettext_x86_gcc2_libintl-0.18.1.1-5
+	glu_x86_gcc2-9.0.0-2
+	glu_x86_gcc2_devel-9.0.0-2
+	icu_x86_gcc2-4.8.1.1-4
+	icu_x86_gcc2_devel-4.8.1.1-4
+	jpeg_x86_gcc2-9-3
+	jpeg_x86_gcc2_devel-9-3
+	libiconv_x86_gcc2-1.13.1-6
+	libiconv_x86_gcc2_devel-1.13.1-6
+	libogg_x86_gcc2-1.3.0-2
+	libogg_x86_gcc2_devel-1.3.0-2
+	libpng_x86_gcc2-1.5.12-3
+	libpng_x86_gcc2_devel-1.5.12-3
+	libsolv_x86_gcc2-0.3.0_haiku_2013_06_16-2
+	libsolv_x86_gcc2_devel-0.3.0_haiku_2013_06_16-2
+	libtheora_x86_gcc2-1.1.1-2
+	libtheora_x86_gcc2_devel-1.1.1-2
+	libvorbis_x86_gcc2-1.3.2-2
+	libvorbis_x86_gcc2_devel-1.3.2-2
+	libvpx_x86_gcc2-1.0.0-2
+	libvpx_x86_gcc2_devel-1.0.0-2
+	libxml2_x86_gcc2-2.8.0-5
+	libxml2_x86_gcc2_devel-2.8.0-5
+	mesa_x86_gcc2-7.8.2-3
+	mesa_x86_gcc2_devel-7.8.2-3
+	ncurses_x86_gcc2-5.9-10
+	ncurses_x86_gcc2_devel-5.9-10
+	openssl_x86_gcc2-1.0.0j-3
+	openssl_x86_gcc2_devel-1.0.0j-3
+	speex_x86_gcc2-1.2~rc1-2
+	speex_x86_gcc2_devel-1.2~rc1-2
+	sqlite_x86_gcc2-3.7.13-4
+	sqlite_x86_gcc2_devel-3.7.13-4
+	wonderbrush_x86_gcc2-2.1.2-4
+	zlib_x86_gcc2-1.2.8-3
+	zlib_x86_gcc2_devel-1.2.8-3
+	:
+	# source packages
+	apr
+	autoconf
+	automake
+#	bepdf
+	binutils
+	binutils_x86_gcc2
+	bison
+	bzip2
+	cdrtools
+	cmake
+	ctags
+	curl
+	cvs
+	doxygen
+	expat
+	ffmpeg
+	flex
+	freetype
+	gcc
+	gcc_x86_gcc2
+	gettext
+	git
+	glu
+	gperf
+	grep
+	groff
+	haikuwebkit
+	htmldoc
+	icu
+	jam
+	jpeg
+	keymapswitcher
+	libedit
+	libiconv
+	libogg
+	libpcre
+	libpng
+	libsolv
+	libtheora
+	libtool
+	libvorbis
+	libvpx
+	libxml2
+	m4
+	make
+	man
+	mercurial
+	mesa
+	mesa_x86_gcc2
+	mkdepend
+	nano
+	ncurses
+	neon
+	openssh
+	openssl
+	p7zip
+	pe
+	perl
+	pkgconfig
+	python
+	readline
+	scons
+	sed
+	speex
+	sqlite
+	subversion
+	tar
+	texi2html
+	texinfo
+	vision
+	wpa_supplicant
+	yasm
+	xz_utils
+	zlib
+	:
+	# debuginfo packages
+	grep
+	sed
+	tar
+	;

build/jam/repositories/HaikuPorts/x86_64

@@ -0,0 +1,198 @@
+RemotePackageRepository HaikuPorts
+	: x86_64
+	: http://haiku-files.org/files/repo
+	:
+	# architecture "any" packages
+	be_book-2008_10_26-1
+	ca_root_certificates-2012_12_29-1
+	texi2html-1.82-2
+	timgmsoundfont-2004_01_24-4
+	wqy_microhei-0.2.0~beta-3
+	:
+	# repository architecture packages
+	# primary architecture (x86_64)
+	apr-1.4.6-7
+	apr_devel-1.4.6-7
+	apr_util-1.4.1-4
+	apr_util_devel-1.4.1-4
+	autoconf-2.69-4
+	automake-1.13.1-4
+#	bepdf-1.1.1~beta5_2013_04_28-1
+	binutils-2.23.2_2013_04_09-2
+	bison-2.4.3-5
+	bzip2-1.0.6-3
+	cdrtools-3.01~a07-3
+	cmake-2.8.5-6
+	ctags-5.8-3
+	curl-7.26.0-5
+	curl_devel-7.26.0-5
+	cvs-1.12.13.1-5
+	doxygen-1.6.3-4
+	expat-2.0.1-7
+	expat_devel-2.0.1-7
+#	ffmpeg-0.10.2-4
+#	ffmpeg_devel-0.10.2-4
+	flex-2.5.35-6
+	freetype-2.4.9-3
+	freetype_devel-2.4.9-3
+	gcc-4.7.3_2013_08_12-2
+	gettext-0.18.1.1-5
+	gettext_libintl-0.18.1.1-5
+	git-1.8.3.4-1
+	git_arch-1.8.3.4-1
+	git_cvs-1.8.3.4-1
+	git_daemon-1.8.3.4-1
+	git_email-1.8.3.4-1
+	git_svn-1.8.3.4-1
+	glu-9.0.0-2
+	glu_devel-9.0.0-2
+	gperf-3.0.4-1
+	grep-2.14-5
+	groff-1.20.1-2
+	haikuwebkit-1.1.3_2013_08_09-2
+	haikuwebkit_devel-1.1.3_2013_08_09-2
+	htmldoc-1.8.27-3
+	icu-4.8.1.1-4
+	icu_devel-4.8.1.1-4
+	jam-2.5_2012_10_12-1
+	jpeg-9-3
+	jpeg_devel-9-3
+	jpeg_tools-9-3
+	keymapswitcher-1.2.7.10-1
+	libedit-2012_06_01_3.0-1
+	libiconv-1.13.1-6
+	libiconv_devel-1.13.1-6
+#	libogg-1.3.0-2
+#	libogg_devel-1.3.0-2
+	libpcre-8.21-5
+	libpcre_devel-8.21-5
+	libpng-1.5.12-3
+	libpng_devel-1.5.12-3
+	libsolv-0.3.0_haiku_2013_06_16-2
+	libsolv_devel-0.3.0_haiku_2013_06_16-2
+#	libtheora-1.1.1-2
+#	libtheora_devel-1.1.1-2
+	libtool-2.4-8
+	libtool_libltdl-2.4-8
+#	libvorbis-1.3.2-2
+#	libvorbis_devel-1.3.2-2
+#	libvpx-1.0.0-2
+#	libvpx_devel-1.0.0-2
+	libxml2-2.8.0-5
+	libxml2_devel-2.8.0-5
+	libxml2_python-2.8.0-5
+	m4-1.4.16-5
+	make-3.82-5
+	man-1.6g-2
+	mercurial-2.2.2-3
+	mesa-9.1.1-1
+	mesa_devel-9.1.1-1
+	mkdepend-1.7-3
+	nano-2.2.6-3
+	ncurses-5.9-10
+	ncurses_devel-5.9-10
+	neon-0.29.6-7
+	neon_devel-0.29.6-7
+	openssh-6.0p1-7
+	openssl-1.0.0j-3
+	openssl_devel-1.0.0j-3
+	p7zip-9.20.1-5
+	pe-2.4.3_hg611-1
+	perl-5.10.1-6
+	pkgconfig-0.27.1-1
+	python-2.6.8-5
+	readline-6.2-3
+	scons-2.2.0-1
+	sed-4.2.1-6
+#	speex-1.2~rc1-2
+#	speex_devel-1.2~rc1-2
+	sqlite-3.7.13-4
+	sqlite_devel-3.7.13-4
+	subversion-1.6.18-6
+	subversion_devel-1.6.18-6
+	tar-1.26-6
+	texinfo-4.13a-7
+	vision-0.9.7.r945-1
+	wpa_supplicant-2.0-3
+	xz_utils-5.0.4-2
+	yasm-1.2.0-3
+	zlib-1.2.8-3
+	zlib_devel-1.2.8-3
+
+	:
+
+	# source packages
+	apr
+	autoconf
+	automake
+#	bepdf
+	binutils
+	bison
+	bzip2
+	cdrtools
+	cmake
+	ctags
+	curl
+	cvs
+	doxygen
+	expat
+#	ffmpeg
+	flex
+	freetype
+	gcc
+	gettext
+	git
+	glu
+	gperf
+	grep
+	groff
+	haikuwebkit
+	htmldoc
+	icu
+	jam
+	jpeg
+	keymapswitcher
+	libedit
+	libiconv
+#	libogg
+	libpcre
+	libpng
+	libsolv
+#	libtheora
+	libtool
+#	libvorbis
+#	libvpx
+	libxml2
+	m4
+	make
+	man
+	mercurial
+	mesa
+	mkdepend
+	nano
+	ncurses
+	neon
+	openssh
+	openssl
+	p7zip
+	pe
+	perl
+	pkgconfig
+	python
+	readline
+	scons
+	sed
+#	speex
+	sqlite
+	subversion
+	tar
+	texi2html
+	texinfo
+	vision
+	wpa_supplicant
+	yasm
+	xz_utils
+	zlib
+	:
+	# debuginfo packages
+	;

build/jam/repositories/HaikuPorts/x86_gcc2

@@ -0,0 +1,251 @@
+RemotePackageRepository HaikuPorts
+	: x86_gcc2
+	: http://haiku-files.org/files/repo
+	:
+	# architecture "any" packages
+	be_book-2008_10_26-1
+	ca_root_certificates-2012_12_29-1
+	texi2html-1.82-2
+	timgmsoundfont-2004_01_24-3
+	wqy_microhei-0.2.0~beta-3
+	:
+	# repository architecture packages
+	# primary architecture (x86_gcc2)
+	apr-1.4.6-7
+	apr_devel-1.4.6-7
+	apr_util-1.4.1-3
+	apr_util_devel-1.4.1-3
+	autoconf-2.69-4
+	automake-1.13.1-4
+	bepdf-1.1.1~beta5_2013_04_28-1
+#	bezillabrowser-2.0.0.22pre_2010_05_02-1
+	binutils-2.17_2013_04_21-2
+	bison-2.4.3-5
+	bzip2-1.0.6-3
+	cdrtools-3.01~a07-3
+	cmake-2.8.5-6
+	ctags-5.8-3
+	curl-7.26.0-5
+	curl_devel-7.26.0-5
+	cvs-1.12.13.1-5
+	doxygen-1.6.3-3
+	expat-2.0.1-7
+	expat_devel-2.0.1-7
+	ffmpeg-0.10.2-4
+	ffmpeg_devel-0.10.2-4
+	flex-2.5.35-6
+	freetype-2.4.9-3
+	freetype_devel-2.4.9-3
+	gcc-2.95.3_2013_08_15-2
+	gettext-0.18.1.1-5
+	gettext_libintl-0.18.1.1-5
+	git-1.8.3.4-1
+	git_arch-1.8.3.4-1
+	git_cvs-1.8.3.4-1
+	git_daemon-1.8.3.4-1
+	git_email-1.8.3.4-1
+	git_svn-1.8.3.4-1
+	glu-9.0.0-2
+	glu_devel-9.0.0-2
+	gperf-3.0.4-1
+	grep-2.14-5
+	groff-1.20.1-2
+	htmldoc-1.8.27-3
+	icu-4.8.1.1-4
+	icu_devel-4.8.1.1-4
+	jam-2.5_2012_10_12-1
+	jpeg-9-3
+	jpeg_devel-9-3
+	jpeg_tools-9-3
+	keymapswitcher-1.2.7.10-1
+	libedit-2012_06_01_3.0-1
+	libiconv-1.13.1-6
+	libiconv_devel-1.13.1-6
+	libogg-1.3.0-2
+	libogg_devel-1.3.0-2
+	libpcre-8.21-5
+	libpng-1.5.12-3
+	libpng_devel-1.5.12-3
+	libsolv-0.3.0_haiku_2013_06_16-2
+	libsolv_devel-0.3.0_haiku_2013_06_16-2
+	libtheora-1.1.1-2
+	libtheora_devel-1.1.1-2
+	libtool-2.4-8
+	libtool_libltdl-2.4-8
+	libvorbis-1.3.2-2
+	libvorbis_devel-1.3.2-2
+	libvpx-1.0.0-2
+	libvpx_devel-1.0.0-2
+	libxml2-2.8.0-5
+	libxml2_devel-2.8.0-5
+	libxml2_python-2.8.0-5
+	m4-1.4.16-5
+	make-3.82-5
+	man-1.6g-2
+	mercurial-2.2.2-3
+	mesa-7.8.2-3
+	mesa_devel-7.8.2-3
+	mkdepend-1.7-3
+	nano-2.2.6-3
+	ncurses-5.9-9
+	ncurses_devel-5.9-9
+	neon-0.29.6-6
+	neon_devel-0.29.6-6
+	openssh-6.0p1-8
+	openssl-1.0.0j-3
+	openssl_devel-1.0.0j-3
+	p7zip-9.20.1-4
+	pe-2.4.3_hg602-4
+	perl-5.10.1-6
+	pkgconfig-0.27.1-1
+	python-2.6.8-4
+	readline-6.2-3
+	scons-2.2.0-1
+	sed-4.2.1-6
+	speex-1.2~rc1-2
+	speex_devel-1.2~rc1-2
+	sqlite-3.7.13-4
+	sqlite_devel-3.7.13-4
+	subversion-1.6.18-6
+	subversion_devel-1.6.18-6
+	tar-1.26-6
+	texinfo-4.13a-7
+	vision-0.9.7.r944-1
+	wonderbrush-2.1.2-4
+	wpa_supplicant-2.0-3
+	yasm-1.2.0-3
+	zlib-1.2.8-3
+	zlib_devel-1.2.8-3
+
+	# secondary architecture (x86)
+	binutils_x86-2.23.2_2013_04_09-1
+	curl_x86-7.26.0-5
+	curl_x86_devel-7.26.0-5
+	expat_x86-2.0.1-7
+	expat_x86_devel-2.0.1-7
+	ffmpeg_x86-0.10.2-3
+	ffmpeg_x86_devel-0.10.2-3
+	freetype_x86-2.4.9-3
+	freetype_x86_devel-2.4.9-3
+	gcc_x86-4.7.3_2013_08_12-2
+	gettext_x86-0.18.1.1-5
+	gettext_x86_libintl-0.18.1.1-5
+	glu_x86-9.0.0-2
+	glu_x86_devel-9.0.0-2
+	haikuwebkit_x86-1.1.3_2013_08_09-2
+	haikuwebkit_x86_devel-1.1.3_2013_08_09-2
+	icu_x86-4.8.1.1-4
+	icu_x86_devel-4.8.1.1-4
+	jpeg_x86-9-3
+	jpeg_x86_devel-9-3
+	libiconv_x86-1.13.1-6
+	libiconv_x86_devel-1.13.1-6
+	libogg_x86-1.3.0-2
+	libogg_x86_devel-1.3.0-2
+	libpng_x86-1.5.12-3
+	libpng_x86_devel-1.5.12-3
+	libsolv_x86-0.3.0_haiku_2013_06_16-2
+	libsolv_x86_devel-0.3.0_haiku_2013_06_16-2
+	libtheora_x86-1.1.1-2
+	libtheora_x86_devel-1.1.1-2
+	libvorbis_x86-1.3.2-2
+	libvorbis_x86_devel-1.3.2-2
+	libvpx_x86-1.0.0-2
+	libvpx_x86_devel-1.0.0-2
+	libxml2_x86-2.8.0-5
+	libxml2_x86_devel-2.8.0-5
+	mesa_x86-9.1.1-1
+	mesa_x86_devel-9.1.1-1
+	ncurses_x86-5.9-9
+	ncurses_x86_devel-5.9-9
+	openssl_x86-1.0.0j-3
+	openssl_x86_devel-1.0.0j-3
+	speex_x86-1.2~rc1-2
+	speex_x86_devel-1.2~rc1-2
+	sqlite_x86-3.7.13-4
+	sqlite_x86_devel-3.7.13-4
+	xz_utils_x86-5.0.4-1
+	zlib_x86-1.2.8-3
+	zlib_x86_devel-1.2.8-3
+	:
+	# source packages
+	apr
+	autoconf
+	automake
+	bepdf
+	binutils
+	binutils_x86
+	bison
+	bzip2
+	cdrtools
+	cmake
+	ctags
+	curl
+	cvs
+	doxygen
+	expat
+	ffmpeg
+	flex
+	freetype
+	gcc
+	gcc_x86
+	gettext
+	git
+	glu
+	gperf
+	grep
+	groff
+	haikuwebkit_x86
+	htmldoc
+	icu
+	jam
+	jpeg
+	keymapswitcher
+	libedit
+	libiconv
+	libogg
+	libpcre
+	libpng
+	libsolv
+	libtheora
+	libtool
+	libvorbis
+	libvpx
+	libxml2
+	m4
+	make
+	man
+	mercurial
+	mesa
+	mesa_x86
+	mkdepend
+	nano
+	ncurses
+	neon
+	openssh
+	openssl
+	p7zip
+	pe
+	perl
+	pkgconfig
+	python
+	readline
+	scons
+	sed
+	speex
+	sqlite
+	subversion
+	tar
+	texi2html
+	texinfo
+	vision
+	wpa_supplicant
+	yasm
+	xz_utils_x86
+	zlib
+	:
+	# debuginfo packages
+	grep
+	sed
+	tar
+	;

build/jam/repositories/HaikuPortsCross/x86

@@ -0,0 +1,74 @@
+BootstrapPackageRepository HaikuPortsCross
+	: x86
+	:
+	# architecture "any" packages
+	haikuporter-0-1
+	:
+	# repository architecture packages (stage 1)
+	autoconf_bootstrap-2.69-1
+	automake_bootstrap-1.13.1-1
+	binutils_bootstrap-2.23.2_2013_04_09-3
+	bison_bootstrap-2.4.3-1
+	flex_bootstrap-2.5.35-1
+	freetype_bootstrap-2.4.9-1
+	freetype_bootstrap_devel-2.4.9-1
+	gcc_bootstrap-4.7.3_2013_08_12-1
+	grep_bootstrap-2.14-1
+	icu_bootstrap-4.8.1.1-1
+	icu_bootstrap_devel-4.8.1.1-1
+	libtool_bootstrap-2.4-8
+	libtool_bootstrap_libltdl-2.4-8
+	m4_bootstrap-1.4.16-1
+	make_bootstrap-3.82-1
+	ncurses_bootstrap-5.9-1
+	ncurses_bootstrap_devel-5.9-1
+	python_bootstrap-2.6.8-1
+	sed_bootstrap-4.2.1-1
+	texinfo_bootstrap-4.13a-1
+	zlib_bootstrap-1.2.8-2
+	zlib_bootstrap_devel-1.2.8-2
+
+	secondary_x86_gcc2 @{
+		binutils_bootstrap_x86_gcc2-2.17_2013_04_21-3
+		freetype_bootstrap_x86_gcc2-2.4.9-1
+		freetype_bootstrap_x86_gcc2_devel-2.4.9-1
+		gcc_bootstrap_x86_gcc2-2.95.3_2013_08_15-1
+		icu_bootstrap_x86_gcc2-4.8.1.1-1
+		icu_bootstrap_x86_gcc2_devel-4.8.1.1-1
+		ncurses_bootstrap_x86_gcc2-5.9-1
+		ncurses_bootstrap_x86_gcc2_devel-5.9-1
+		zlib_bootstrap_x86_gcc2-1.2.8-2
+		zlib_bootstrap_x86_gcc2_devel-1.2.8-2
+	}@ # secondary_x86_gcc2
+	:
+	# repository architecture packages (stage 2)
+	libsolv_bootstrap-0.3.0_haiku_2013_06_16-1
+	libsolv_bootstrap_devel-0.3.0_haiku_2013_06_16-1
+
+	secondary_x86_gcc2 @{
+		libsolv_bootstrap_x86_gcc2-0.3.0_haiku_2013_06_16-1
+		libsolv_bootstrap_x86_gcc2_devel-0.3.0_haiku_2013_06_16-1
+	}@ # secondary_x86_gcc2
+	:
+	# source packages
+	autoconf_bootstrap
+	automake_bootstrap
+	binutils_bootstrap
+	bison_bootstrap
+	flex_bootstrap
+	freetype_bootstrap
+	gawk_bootstrap
+	gcc_bootstrap
+	grep_bootstrap
+	libsolv_bootstrap
+	libtool_bootstrap
+	m4_bootstrap
+	make_bootstrap
+	ncurses_bootstrap
+	python_bootstrap
+	sed_bootstrap
+	texinfo_bootstrap
+	zlib_bootstrap
+	:
+	# debuginfo packages
+	;

build/jam/repositories/HaikuPortsCross/x86_64

@@ -0,0 +1,57 @@
+BootstrapPackageRepository HaikuPortsCross
+	: x86_64
+	:
+	# architecture "any" packages
+	haikuporter-0-1
+	:
+	# repository architecture packages (stage 1)
+	autoconf_bootstrap-2.69-1
+	automake_bootstrap-1.13.1-1
+	binutils_bootstrap-2.23.2_2013_04_09-3
+	bison_bootstrap-2.4.3-1
+	flex_bootstrap-2.5.35-1
+	freetype_bootstrap-2.4.9-1
+	freetype_bootstrap_devel-2.4.9-1
+	gcc_bootstrap-4.7.3_2013_08_12-1
+	grep_bootstrap-2.14-1
+	icu_bootstrap-4.8.1.1-1
+	icu_bootstrap_devel-4.8.1.1-1
+	libtool_bootstrap-2.4-8
+	libtool_bootstrap_libltdl-2.4-8
+	m4_bootstrap-1.4.16-1
+	make_bootstrap-3.82-1
+	ncurses_bootstrap-5.9-1
+	ncurses_bootstrap_devel-5.9-1
+	python_bootstrap-2.6.8-1
+	sed_bootstrap-4.2.1-1
+	texinfo_bootstrap-4.13a-1
+	zlib_bootstrap-1.2.8-2
+	zlib_bootstrap_devel-1.2.8-2
+	:
+	# repository architecture packages (stage 2)
+	libsolv_bootstrap-0.3.0_haiku_2013_06_16-1
+	libsolv_bootstrap_devel-0.3.0_haiku_2013_06_16-1
+
+	:
+	# source packages
+	autoconf_bootstrap
+	automake_bootstrap
+	binutils_bootstrap
+	bison_bootstrap
+	flex_bootstrap
+	freetype_bootstrap
+	gawk_bootstrap
+	gcc_bootstrap
+	grep_bootstrap
+	libsolv_bootstrap
+	libtool_bootstrap
+	m4_bootstrap
+	make_bootstrap
+	ncurses_bootstrap
+	python_bootstrap
+	sed_bootstrap
+	texinfo_bootstrap
+	zlib_bootstrap
+	:
+	# debuginfo packages
+	;

build/jam/repositories/HaikuPortsCross/x86_gcc2

@@ -0,0 +1,74 @@
+BootstrapPackageRepository HaikuPortsCross
+	: x86_gcc2
+	:
+	# architecture "any" packages
+	haikuporter-0-1
+	:
+	# repository architecture packages (stage 1)
+	autoconf_bootstrap-2.69-1
+	automake_bootstrap-1.13.1-1
+	binutils_bootstrap-2.17_2013_04_21-3
+	bison_bootstrap-2.4.3-1
+	flex_bootstrap-2.5.35-1
+	freetype_bootstrap-2.4.9-1
+	freetype_bootstrap_devel-2.4.9-1
+	gcc_bootstrap-2.95.3_2013_08_15-1
+	grep_bootstrap-2.14-1
+	icu_bootstrap-4.8.1.1-1
+	icu_bootstrap_devel-4.8.1.1-1
+	libtool_bootstrap-2.4-8
+	libtool_bootstrap_libltdl-2.4-8
+	m4_bootstrap-1.4.16-1
+	make_bootstrap-3.82-1
+	ncurses_bootstrap-5.9-1
+	ncurses_bootstrap_devel-5.9-1
+	python_bootstrap-2.6.8-1
+	sed_bootstrap-4.2.1-1
+	texinfo_bootstrap-4.13a-1
+	zlib_bootstrap-1.2.8-2
+	zlib_bootstrap_devel-1.2.8-2
+
+	secondary_x86 @{
+		binutils_bootstrap_x86-2.23.2_2013_04_09-3
+		freetype_bootstrap_x86-2.4.9-1
+		freetype_bootstrap_x86_devel-2.4.9-1
+		gcc_bootstrap_x86-4.7.3_2013_08_12-1
+		icu_bootstrap_x86-4.8.1.1-1
+		icu_bootstrap_x86_devel-4.8.1.1-1
+		ncurses_bootstrap_x86-5.9-1
+		ncurses_bootstrap_x86_devel-5.9-1
+		zlib_bootstrap_x86-1.2.8-2
+		zlib_bootstrap_x86_devel-1.2.8-2
+	}@ # secondary_x86
+	:
+	# repository architecture packages (stage 2)
+	libsolv_bootstrap-0.3.0_haiku_2013_06_16-1
+	libsolv_bootstrap_devel-0.3.0_haiku_2013_06_16-1
+
+	secondary_x86 @{
+		libsolv_bootstrap_x86-0.3.0_haiku_2013_06_16-1
+		libsolv_bootstrap_x86_devel-0.3.0_haiku_2013_06_16-1
+	}@ # secondary_x86
+	:
+	# source packages
+	autoconf_bootstrap
+	automake_bootstrap
+	binutils_bootstrap
+	bison_bootstrap
+	flex_bootstrap
+	freetype_bootstrap
+	gawk_bootstrap
+	gcc_bootstrap
+	grep_bootstrap
+	libsolv_bootstrap
+	libtool_bootstrap
+	m4_bootstrap
+	make_bootstrap
+	ncurses_bootstrap
+	python_bootstrap
+	sed_bootstrap
+	texinfo_bootstrap
+	zlib_bootstrap
+	:
+	# debuginfo packages
+	;

build/scripts/build_cross_tools

@@ -1,19 +1,19 @@
 #!/bin/sh
 
-# Parameters <haiku sourcedir> <buildtools dir> <haiku output dir>
+# Parameters <haiku sourcedir> <buildtools dir> <install dir>
 # Influential environmental variable:
 # * haikuRequiredLegacyGCCVersion: The required version of the gcc. Will be
 #   checked against the version in the buildtools directory.
 
 # get and check the parameters
 if [ $# -lt 3 ]; then
-	echo Usage: $0 '<haiku sourcedir> <buildtools dir> <haiku output dir>' >&2
+	echo Usage: $0 '<haiku sourcedir> <buildtools dir> <install dir>' >&2
 	exit 1
 fi
 
 haikuSourceDir=$1
 buildToolsDir=$2/legacy
-haikuOutputDir=$3
+installDir=$3
 shift 3
 additionalMakeArgs=$*
 	# Note: The gcc 2 build has trouble with -jN N > 1, hence we only use the
@@ -62,7 +62,7 @@ fi
 
 
 # create the output dir
-mkdir -p $haikuOutputDir || exit 1
+mkdir -p $installDir || exit 1
 
 
 # get absolute paths
@@ -76,13 +76,13 @@ cd $buildToolsDir
 buildToolsDir=`pwd`
 cd $currentDir
 
-cd $haikuOutputDir
+cd $installDir
-haikuOutputDir=`pwd`
+installDir=`pwd`
+cd $currentDir
 
 
 # create the object and installation directories for the cross compilation tools
-installDir=$haikuOutputDir/cross-tools
+objDir=${installDir}-build
-objDir=$haikuOutputDir/cross-tools-build
 binutilsObjDir=$objDir/binutils
 gccObjDir=$objDir/gcc
 tmpIncludeDir=$objDir/sysincludes
@@ -94,6 +94,11 @@ mkdir -p $installDir $objDir $binutilsObjDir $gccObjDir $tmpIncludeDir \
 	$tmpLibDir || exit 1
 mkdir -p $installDir/lib/gcc-lib/i586-pc-haiku/$haikuRequiredLegacyGCCVersion
 
+gccConfigureArgs=
+if [ -n "$SECONDARY_ARCH" ]; then
+	gccConfigureArgs="$gccConfigureArgs --with-hybrid-secondary=$SECONDARY_ARCH"
+fi
+
 # force the POSIX locale, as the build (makeinfo) might choke otherwise
 export LC_ALL=POSIX
 
@@ -108,8 +113,8 @@ cd $binutilsObjDir
 CFLAGS="-O2" CXXFLAGS="-O2" $buildToolsDir/binutils/configure \
 	--prefix=$installDir $buildHostSpec --target=i586-pc-haiku \
 	--disable-nls --enable-shared=yes --disable-werror || exit 1
-make $additionalMakeArgs || exit 1
+$MAKE $additionalMakeArgs || exit 1
-make $additionalMakeArgs install || exit 1
+$MAKE $additionalMakeArgs install || exit 1
 
 PATH=$PATH:$installDir/bin
 export PATH
@@ -153,7 +158,7 @@ esac
 CFLAGS="-O2 -U_FORTIFY_SOURCE" CXXFLAGS="-O2" $buildToolsDir/gcc/configure \
 	--prefix=$installDir $buildHostSpec --target=i586-pc-haiku \
 	--disable-nls --enable-shared=yes --enable-languages=c,c++ \
-	--with-headers=$tmpIncludeDir --with-libs=$tmpLibDir \
+	--with-headers=$tmpIncludeDir --with-libs=$tmpLibDir $gccConfigureArgs \
 	|| exit 1
 unset CC
 
@@ -168,13 +173,13 @@ eval "sed $sedExpr Makefile.bak > Makefile" || exit 1
 rm Makefile.bak
 
 # make gcc
-make cross || {
+$MAKE cross || {
 	echo "ERROR: Building gcc failed." >&2
 	exit 1
 }
 
 # install gcc
-make install-gcc-cross || {
+$MAKE install-gcc-cross || {
 	echo "ERROR: Installing the cross compiler failed." >&2
 	exit 1
 }
@@ -184,6 +189,11 @@ make install-gcc-cross || {
 # equivalent.
 rm -f $installDir/lib/gcc-lib/i586-pc-haiku/$haikuRequiredLegacyGCCVersion/include/math.h
 
+# Symlink the built-in C++ headers path to the sys-include directory. This is
+# not actually needed for cross compiling Haiku itself, but simplifies using the
+# cross compiler for building the bootstrap packages.
+(cd $installDir/include; ln -s ../i586-pc-haiku/sys-include/c++/2.95.3 g++)
+
 
 # cleanup
 

build/scripts/build_cross_tools_gcc4

@@ -1,31 +1,21 @@
 #!/bin/sh
 #
-# parameters <machine> <haiku sourcedir> <buildtools dir> <haiku output dir>
+# parameters <machine> <haiku sourcedir> <buildtools dir> <isntall dir>
 
 # get and check the parameters
 if [ $# -lt 4 ]; then
 	echo Usage: $0 '<machine> <haiku sourcedir> <buildtools dir>' \
-		'<haiku output dir>' >&2
+		'<install dir>' >&2
 	exit 1
 fi
 
 haikuMachine=$1
 haikuSourceDir=$2
 buildToolsDir=$3
-haikuOutputDir=$4
+installDir=$4
 shift 4
 additionalMakeArgs=$*
 
-case `uname` in
-FreeBSD|OpenBSD)
-	MAKE=gmake
-	;;
-*)
-	MAKE=make
-	;;
-esac
-export MAKE
-
 case $haikuMachine in
 x86_64-*)
 	# GCC's default is to enable multilib, but there is a bug when
@@ -68,7 +58,7 @@ fi
 
 
 # create the output dir
-mkdir -p $haikuOutputDir || exit 1
+mkdir -p $installDir || exit 1
 
 
 # get absolute paths
@@ -82,8 +72,9 @@ cd $buildToolsDir
 buildToolsDir=$(pwd)
 cd $currentDir
 
-cd $haikuOutputDir
+cd $installDir
-haikuOutputDir=$(pwd)
+installDir=$(pwd)
+cd $currentDir
 
 binutilsSourceDir=$buildToolsDir/binutils
 gccSourceDir=$buildToolsDir/gcc
@@ -104,13 +95,13 @@ fi
 find $binutilsSourceDir $gccSourceDir -name \*.info -print0 | xargs -0 touch
 
 # create the object and installation directories for the cross compilation tools
-installDir=$haikuOutputDir/cross-tools
+objDir=${installDir}-build
-objDir=$haikuOutputDir/cross-tools-build
 binutilsObjDir=$objDir/binutils
 gccObjDir=$objDir/gcc
 stdcxxObjDir=$objDir/stdcxx
-tmpIncludeDir=$objDir/sysincludes
+sysrootDir=$installDir/sysroot
-tmpLibDir=$objDir/syslibs
+tmpIncludeDir=$sysrootDir/boot/system/develop/headers
+tmpLibDir=$sysrootDir/boot/system/develop/lib
 
 rm -rf $installDir $objDir
 
@@ -134,6 +125,10 @@ if [ "$HAIKU_USE_GCC_GRAPHITE" = 1 ]; then
 		--with-host-libstdcxx=\"-lstdc++\""
 fi
 
+if [ -n "$SECONDARY_ARCH" ]; then
+	gccConfigureArgs="$gccConfigureArgs --with-hybrid-secondary=$SECONDARY_ARCH"
+fi
+
 # force the POSIX locale, as the build (makeinfo) might choke otherwise
 export LC_ALL=POSIX
 
@@ -142,7 +137,9 @@ cd $binutilsObjDir
 CFLAGS="-O2" CXXFLAGS="-O2" $binutilsSourceDir/configure \
 	--prefix=$installDir $buildHostSpec --target=$haikuMachine \
 	--enable-targets=$haikuMachine,i386-efi-pe,x86_64-efi-pe \
-	--disable-nls --disable-shared --disable-werror $binutilsConfigureArgs \
+	--disable-nls --disable-shared --disable-werror \
+	--with-sysroot=$sysrootDir \
+	$binutilsConfigureArgs \
 	|| exit 1
 $MAKE $additionalMakeArgs || exit 1
 $MAKE $additionalMakeArgs install || exit 1
@@ -203,7 +200,7 @@ CFLAGS="-O2" CXXFLAGS="-O2" $gccSourceDir/configure \
 	--prefix=$installDir $buildHostSpec --target=$haikuMachine \
 	--disable-nls --disable-shared --with-system-zlib \
 	--enable-languages=c,c++ --enable-lto --enable-frame-pointer \
-	--with-headers=$tmpIncludeDir --with-libs=$tmpLibDir \
+	--with-sysroot=$sysrootDir \
 	$gccConfigureArgs \
 	|| exit 1
 
@@ -247,6 +244,9 @@ fi
 # Only the ones from the source tree should be used.
 rm -rf $installDir/$haikuMachine/sys-include
 
+# remove the sysroot dir
+rm -rf $sysrootDir
+
 # remove the objects dir
 rm -rf $objDir
 

build/scripts/build_haiku_image

@@ -6,19 +6,25 @@ set -o errexit
 # outputDir
 # tmpDir
 # addBuildCompatibilityLibDir
+# systemPackages, commonPackages - lists of the hpkg packages copied/updated
+#   (in "system" and "common" respectively)
+# repositories - all repository files
+# downloadDir
 # The following are only for image types:
 # installDir
 # isImage
 # imagePath
 # imageSize
 # imageLabel
+# resolvePackageDependencies
 # updateOnly
 # dontClearImage
 # isVMwareImage
-# optionalPackageDescriptions
 #
 # addattr
 # copyattr
+# getPackageDependencies
+# package
 # rc
 # rmAttrs
 # unzip
@@ -31,7 +37,6 @@ set -o errexit
 # The following is only for cd types:
 # generate_attribute_stores
 # isCD
-# stripCommand
 #
 if [ $# -gt 0 ]; then
 	. $1
@@ -142,29 +147,24 @@ else
 fi
 
 
-stripDebugInfo()
+is_in_list()
 {
-	file="$1"
+	local element
-
+	for element in $2; do
-	# Determine whether the file is an ELF file by checking the ELF signature,
+		if [ "$1" = "$element" ]; then
-	# or at least the printable characters.
+			return 0
-	elfMarker=`dd "if=$file" bs=1 skip=1 count=3 2> /dev/null`
+		fi
-	if [ "$elfMarker" = 'ELF' ]; then
+	done
-		# make user-writable first -- some files aren't
+	return 1
-		chmod u+w "$file"
-		"$stripCommand" --strip-debug "$file"
-	fi
 }
 
+
 extractFile()
 {
-	# extractFile <archive> <directory> <extractedSubDir> <stripDebugSymbols>
+	# extractFile <archive> <directory> <extractedSubDir>
 	archiveFile=$1
 	targetExtractedDir=$2
 	extractedSubDir=$3
-	stripDebugSymbols=$4
-
-	echo "Extracting $archiveFile ..."
 
 	extractDir=$tmpDir/extract
 	$rmAttrs -rf "$extractDir"
@@ -172,13 +172,25 @@ extractFile()
 
 	case "$archiveFile" in
 		*.zip)
+			echo "Extracting $archiveFile ..."
 			$unzip -q -d "$extractDir" "$archiveFile"
 			;;
 		*.tgz|*.tar.gz)
+			echo "Extracting $archiveFile ..."
 			tar -C "$extractDir" -xf "$archiveFile"
 			;;
+		*.hpkg)
+			echo "Extracting $archiveFile ..."
+			if [ -n "$extractedSubDir" ]; then
+				$package extract -C "$extractDir" "$archiveFile" \
+					"$extractedSubDir"
+			else
+				$package extract -C "$extractDir" "$archiveFile"
+			fi
+			;;
 		*)
-			echo "Unhandled archive extension in build_haiku_image extractFile()"
+			echo "Unhandled archive extension in build_haiku_image" \
+				"extractFile()"
 			exit 1
 			;;
 	esac
@@ -189,36 +201,27 @@ extractFile()
 		rm $extractDir/.OptionalPackageDescription
 	fi
 
-	if [ "$stripDebugSymbols" = "1" ]; then
+	$cp -r "${sPrefix}$extractDir/$extractedSubDir/." \
-		# strip executables in common/bin
+		"${tPrefix}$targetExtractedDir"
-		if [ -d $extractDir/common/bin ]; then
-			for file in `find $extractDir/common/bin -type f -a -perm +100 \
-					-a -size +1k`; do
-				stripDebugInfo "$file"
-			done
-		fi
-
-		# strip libraries in common/lib
-		if [ -d $extractDir/common/lib ]; then
-			for file in `find $extractDir/common/lib -type f -a -size +1k \
-					-a -name lib\*`; do
-				stripDebugInfo "$file"
-			done
-		fi
-	fi
-
-	$cp -r "${sPrefix}$extractDir/$extractedSubDir/." "${tPrefix}$targetExtractedDir"
 
 	$rmAttrs -rf "$extractDir"
 }
 
 
+downloadFile()
+{
+	url=$1
+	path=$2
+
+	if [ ! -f "$path" ]; then
+		wget -O "$path" "$url"
+	fi
+}
+
+
 mkdir -p $tmpDir
 copyrightsFile=$tmpDir/copyrights
 $rmAttrs -f $copyrightsFile
-if [ "$optionalPackageDescriptions" ]; then
-	cp "$optionalPackageDescriptions" $copyrightsFile
-fi
 
 if [ $isCD ]; then
 	# setup output dir
@@ -274,70 +277,66 @@ while [ $# -gt 0 ]; do
 done
 
 
-# install MIME database
+# resolve package dependencies
-# TODO: It should be possible to do that in the build system too.
+if [ -n "$resolvePackageDependencies" ]; then
+	echo "Resolving package dependencies ..."
 
-if [ ! $updateOnly ]; then
+	# additional packages for system
-	mimeDBSource=$sourceDir/src/data/beos_mime
+	packageUrls=`$getPackageDependencies $repositories -- $systemPackages`
-	mimeDBDest=${tPrefix}home/config/settings/beos_mime
+	for packageUrl in $packageUrls; do
-
+		packageFileName=`basename $packageUrl`
-	echo "Deleting old MIME database ..."
+		packageFilePath="$downloadDir/$packageFileName"
-
+		downloadFile $packageUrl "$packageFilePath"
-	$rm -rf $mimeDBDest
+		$cp "${sPrefix}$packageFilePath" "${tPrefix}system/packages"
-	$mkdir -p $mimeDBDest
+		systemPackages="$systemPackages $packageFilePath"
-	mimeTmpDir=$tmpDir/mime
-	mimeDBTmpDir=$tmpDir/mime/db
-	mimeTmpIndex=0
-	mimeTmpFile=$mimeTmpDir/mimedb$$.rsrc
-
-	# create tmp dir for the MIME conversion stuff
-	mkdir -p $mimeDBTmpDir
-
-	echo "Installing MIME database ..."
-
-	for inSuperFile in $mimeDBSource/*.super; do
-		superType=$(basename $inSuperFile .super)
-		tmpSuperDir=$mimeDBTmpDir/$superType
-
-		# compile rdef to rsrc file and the rsrc file to attributes
-		$rc -o $mimeTmpFile $inSuperFile
-		mkdir -p $tmpSuperDir
-		$resattr -O -o $tmpSuperDir $mimeTmpFile
-		$rmAttrs $mimeTmpFile
-
-		# iterate through the sub types
-		for inSubFile in $mimeDBSource/$superType/*; do
-			# check, if the type exists
-			if test -f $inSubFile && grep META:TYPE $inSubFile > /dev/null 2>&1 ; then
-				subType=$(basename $inSubFile)
-				tmpSubFile=$mimeDBTmpDir/$superType/$subType
-
-				# compile rdef to rsrc file and the rsrc file to attributes
-				$rc -o $mimeTmpFile $inSubFile
-				$resattr -O -o $tmpSubFile $mimeTmpFile
-				$rmAttrs $mimeTmpFile
-			fi
-		done
 	done
 
-	$cp -r ${sPrefix}$mimeDBTmpDir/. $mimeDBDest
+	# Remove packages from the list for common, that are already in the package
+	# list for system.
+	unfilteredCommonPackages="$commonPackages"
+	commonPackages=
+	for packageFile in $unfilteredCommonPackages; do
+		if is_in_list "$packageFile" "$systemPackages"; then
+			:
+		else
+			commonPackages="$commonPackages $packageFile"
+		fi
+	done
 
-	# cleanup tmp dir
+	# additional packages for common
-	$rmAttrs -rf $mimeTmpDir
+	packageUrls=`$getPackageDependencies $repositories -- $systemPackages \
-fi	# ! updateOnly
+		$commonPackages`
+	for packageUrl in $packageUrls; do
+		packageFileName=`basename $packageUrl`
+		packageFilePath="$downloadDir/$packageFileName"
+		downloadFile $packageUrl "$packageFilePath"
+		$cp "${sPrefix}$packageFilePath" "${tPrefix}common/packages"
+		commonPackages="$commonPackages $packageFilePath"
+	done
+fi
+
+
+# install default settings for packages
+for packageFile in $systemPackages $commonPackages; do
+	if $package list -p $packageFile | egrep '^settings/' > /dev/null; then
+		extractFile $packageFile common/settings settings
+	fi
+done
 
 
 # add the concatenated copyrights as an attribute to AboutSystem
+# TODO: That might not be necessary, when all third-party software everything
+# is packaged. Though we might not package everything.
 
-if [ ! $updateOnly ]; then
+# if [ ! $updateOnly ]; then
-	if [ -f $copyrightsFile ]; then
+# 	if [ -f $copyrightsFile ]; then
-		copyrightAttrs=$tmpDir/copyrightAttrs
+# 		copyrightAttrs=$tmpDir/copyrightAttrs
-		$rmAttrs -f $copyrightAttrs
+# 		$rmAttrs -f $copyrightAttrs
-		touch $copyrightAttrs
+# 		touch $copyrightAttrs
-		$addattr -f $copyrightsFile COPYRIGHTS $copyrightAttrs
+# 		$addattr -f $copyrightsFile COPYRIGHTS $copyrightAttrs
-		$copyAttrs ${sPrefix}$copyrightAttrs ${tPrefix}system/apps/AboutSystem
+# 		$copyAttrs ${sPrefix}$copyrightAttrs ${tPrefix}system/apps/AboutSystem
-	fi
+# 	fi
-fi
+# fi
 
 if [ $isCD ]; then
 	# generate the attribute stores

build/scripts/build_haiku_package

@@ -0,0 +1,125 @@
+#!/bin/sh
+set -o errexit
+
+# The first argument is the shell script that initializes the variables:
+# addBuildCompatibilityLibDir
+# mimeDB
+# outputDir
+# sourceDir
+# tmpDir
+# compressionLevel
+# updateOnly
+# cc
+#
+# addattr
+# copyattr
+# mimeset
+# package
+# rc
+# rmAttrs
+# unzip
+#
+
+if [ $# -le 1 ]; then
+	echo "$0: Missing parameters!" >&2
+	exit 1
+fi
+
+packagePath="$1"
+packageInfoPath="$2"
+shift 2
+
+if [ $# -gt 0 ]; then
+	. $1
+	shift
+fi
+
+# this adds the build library dir to LD_LIBRARY_PATH
+eval "$addBuildCompatibilityLibDir"
+
+
+# make a clean contents dir
+packageName=`basename "$packagePath"`
+echo "$packageName: Removing and re-creating package contents dir ..."
+contentsDir="$tmpDir/contents"
+$rmAttrs -rf "$contentsDir"
+mkdir -p "$contentsDir"
+
+
+# map the shell commands
+sPrefix=
+tPrefix="$contentsDir/"
+cd=cd
+scd=:
+cp="$copyattr -d"
+copyAttrs="$copyattr"
+ln=ln
+mkdir=mkdir
+rm=$rmAttrs
+mkindex=mkindex
+
+
+extractFile()
+{
+	# extractFile <archive> <directory> <extractedSubDir>
+	archiveFile=$1
+	targetExtractedDir=$2
+	extractedSubDir=$3
+
+	extractDir=$tmpDir/extract
+	$rmAttrs -rf "$extractDir"
+	mkdir -p "$extractDir"
+
+	case "$archiveFile" in
+		*.zip)
+			$unzip -q -d "$extractDir" "$archiveFile"
+			;;
+		*.tgz|*.tar.gz)
+			tar -C "$extractDir" -xf "$archiveFile"
+			;;
+		*.hpkg)
+			if [ -n "$extractedSubDir" ]; then
+				$package extract -C "$extractDir" "$archiveFile" \
+					"$extractedSubDir"
+			else
+				$package extract -C "$extractDir" "$archiveFile"
+			fi
+			;;
+		*)
+			echo "Unhandled archive extension in build_haiku_image" \
+				"extractFile()"
+			exit 1
+			;;
+	esac
+
+	$cp -r "${sPrefix}$extractDir/$extractedSubDir/." \
+		"${tPrefix}$targetExtractedDir"
+
+	$rmAttrs -rf "$extractDir"
+}
+
+
+# execute the scripts preparing the package contents
+echo "$packageName: Collecting package contents ..."
+while [ $# -gt 0 ]; do
+	. $1
+	shift
+done
+
+
+# mimeset the whole package content
+echo "$packageName: mimeset'ing package contents ..."
+$mimeset --mimedb "$mimeDB" "$contentsDir"
+
+
+# create the package
+if [ ! $updateOnly ]; then
+	echo "$packageName: Creating the package ..."
+	rm -f "$packagePath"
+	$package create -q "-$compressionLevel" -i "$packageInfoPath" \
+		-C "$contentsDir" "$packagePath"
+else
+	echo "$packageName: Updating the package ..."
+	$package add -q -f "-$compressionLevel" -i "$packageInfoPath" \
+		-C "$contentsDir" "$packagePath" .
+fi

build/scripts/determine_haiku_revision

@@ -1,70 +1,51 @@
 #!/bin/sh
 
-determineGitRevision()
+haikuTop=$1
-{
+revisionFile=$2
-	haikuTop=$1
+haikuBuildOutputDir=`dirname $revisionFile`
-	haikuBuildOutputDir=$2
+lastBuiltRevisionFile=${haikuBuildOutputDir}/last-built-revision
 
-	revision=`cat ${haikuBuildOutputDir}/haiku-revision 2>/dev/null`
+case `uname` in
-	lastBuiltRevision=`cat ${haikuBuildOutputDir}/last-built-revision \
+Darwin)
-		2>/dev/null`
+	SED=gsed
-	localRev=`git rev-parse HEAD`
+	;;
+*)
+	SED=sed
+	;;
+esac
+export SED
 
-	# only determine the haiku-revision if anything has changed from
+revision=`cat ${revisionFile} 2>/dev/null`
-	# last build
+lastBuiltRevision=`cat $lastBuiltRevisionFile 2>/dev/null`
-	if [ -z "$revision" -o "$lastBuiltRevision" != "$localRev" ]; then
-		# the revision we use is the description of HEAD with respect to the
-		# last reachable hrev-(haiku-revision-)tag
-		revision=`git describe --dirty --tags --match=hrev*`
-		if [ -z "$revision" ]; then
-			# failed to find any hrev tags, use short hash instead
-			revision=`git rev-parse --short HEAD`
-		elif echo "$revision" | grep -- '-' >/dev/null; then
-			# HEAD is not directly a changeset from Haiku's central repo, so we
-			# add the current branch name as additional info
-			branchName=`git branch | grep '*' | cut -b 3-`
-			revision="$revision [$branchName]"
-		fi
-		echo $localRev >${haikuBuildOutputDir}/last-built-revision
-	fi
-}
 
+originalDir=`pwd`
+cd ${haikuTop}
+export LC_ALL=C
 
-determineHaikuRevision()
+localRev=`git rev-parse HEAD`
-{
-	haikuTop=$1
-	haikuBuildOutputDir=$2
 
-	case `uname` in
+# only determine the haiku-revision if anything has changed from
-	Darwin)
+# last build
-		SED=gsed
+if [ -z "$revision" -o "$lastBuiltRevision" != "$localRev" ]; then
-		;;
+	# the revision we use is the description of HEAD with respect to the
-	*)
+	# last reachable hrev-(haiku-revision-)tag
-		SED=sed
+	revision=`git describe --dirty --tags --match=hrev*`
-		;;
-	esac
-	export SED
-
-	originalDir=`pwd`
-	cd ${haikuTop}
-	export LC_ALL=C
-	if [ -d .svn ]; then
-		revision=`svn info 2>/dev/null | grep Revision | awk '{printf $2}'`
-	elif [ -d .git/svn ]; then
-		revision=`git svn info 2>/dev/null | grep Revision | awk '{printf $2}'`
-	elif [ -d .git ]; then
-		determineGitRevision $haikuTop $haikuBuildOutputDir
-	elif [ -d .hg ]; then
-		# Try searching hg log for last svn commit
-		# Extract from "(svn r12345) ..." line
-		revision=`(cd ${haikuTop} &&
-			hg log --no-merges --template "{desc|firstline}\n") 2> /dev/null |
-			grep --max-count=1 "(svn r" |
-			$SED -n -e 's,(svn r\(.*\)).*,\1,p'`
-	fi
 	if [ -z "$revision" ]; then
-		revision=0
+		# failed to find any hrev tags, use short hash instead
+		revision=`git rev-parse --short HEAD`
+	elif echo "$revision" | grep -- '-' >/dev/null; then
+		# HEAD is not directly a changeset from Haiku's central repo, so we
+		# add the current branch name as additional info
+		branchName=`git branch | grep '*' | cut -b 3-`
+		revision="$revision [$branchName]"
 	fi
-	echo $revision >${haikuBuildOutputDir}/haiku-revision
+fi
-	cd $originalDir
+
-}
+cd $originalDir
+
+if [ -z "$revision" ]; then
+	revision=0
+fi
+
+echo $localRev >${lastBuiltRevisionFile}
+echo $revision >${revisionFile}

build/scripts/host_build_only

@@ -0,0 +1,6 @@
+#!/bin/sh
+
+echo "Error: The build has been configured for building the build host tools" \
+	"only." >&2
+exit 1
+

build/scripts/rm_attrs

@@ -9,7 +9,7 @@ rmAttrs=$1
 shift
 
 if [ -f $rmAttrs ]; then
-	$rmAttrs $@
+	$rmAttrs "$@"
 else
-	rm $@
+	rm "$@"
 fi

configure

@@ -12,33 +12,32 @@ usage()
 
 Usage: $0 <options>
 options:
-  --alternative-gcc-output-dir <dir>
+  --bootstrap <haikuporter> <HaikuPorts cross repo> <HaikuPorts repo>
-                              Build a Haiku installation that supports running
+                              Prepare for a bootstrap build. No pre-built
-                              executables built with a gcc version incompatible
+                              packages will be used, instead they will be built
-                              with the primary gcc (e.g. gcc 2 executables under
+                              from the sources (in several phases).
-                              a gcc 4 Haiku or vice versa). <dir> specifies the
+                              <haikuporter> is the path to the haikuporter tool
-                              output directory of the other gcc. The directory
+                              suitable for the host platform.
-                              must already be fully configured.
+                              <HaikuPorts cross repo> is the path to a checked
-                              Note, that a sub-jam will be executed when
+                              out HaikuPorts cross-compilation repository.
-                              building Haiku. When using a jam that is not
+                              <HaikuPorts repo> is the path to a checked out
-                              simply invoked by "jam", the JAM build variable
+                              HaikuPorts repository.
-                              needs to be set accordingly.
+  --build-cross-tools <arch> [ <build tools dir> ]
-                              To disable building the alternative libraries
-                              the variable HAIKU_ADD_ALTERNATIVE_GCC_LIBS can be
-                              unset in the UserBuildConfig file.
-  --build-cross-tools <build tools dir>
                               Assume cross compilation. <build tools dir>
                               defines the location of the build tools sources.
                               They will be compiled and placed in the output
                               directory under "cross-tools". The HAIKU_* tools
                               variables will be set accordingly.
-  --build-cross-tools-gcc4 <arch> <build tools dir>
-                              Like "--build-cross-tools" just that gcc 4 will
-                              be used for cross-compilation. Note, that the
-                              resulting Haiku installation built with gcc 4
-                              will not be binary compatible with BeOS R5.
                               <arch> specifies the target architecture, either
-                              "x86", "x86_64", "ppc", "m68k", "arm" or "mipsel".
+                              "x86_gcc2", "x86", "x86_64", "ppc", "m68k", "arm",
+                              or "mipsel".
+                              This option and --cross-tools-prefix can be
+                              specified multiple times. The first cross tools
+                              specify the primary tools, the subsequent ones the
+                              secondary tools (for "hybrid" images).
+                              For the first --build-cross-tools the
+                              <build tools dir> argument must be specified and
+                              for the subsequent ones it must be omitted.
   --cross-tools-prefix <prefix>
                               Assume cross compilation. <prefix> should be a
                               path to the directory where the cross
@@ -55,6 +54,9 @@ options:
                               default -- any other distro (default value).
   --enable-multiuser          Enable experimental multiuser support.
   --help                      Prints out this help.
+  --host-only                 Configure for building tools for the build host
+                              only. Haiku cannot be built when configured like
+                              this.
   --include-gpl-addons        Include GPL licensed add-ons.
   --include-patented-code     Enable code that is known to implemented patented
                               ideas and techniques. If this option is not
@@ -73,6 +75,14 @@ options:
   --target=TARGET             Select build target platform.
                               [default=${TARGET_PLATFORM}]
                               valid targets=r5,bone,dano,haiku
+  --target-arch <arch>        Haiku only: Specify the target architecture to
+                              build for. Must be one of the architectures of the
+                              host system. The installed build tools for that
+                              architecture will be used.
+                              This option can be specified multiple times. The
+                              first occurrence specifies the primary
+                              architecture of the Haiku to build, subsequent
+                              ones the secondary architectures.
   --update                    re-runs last configure invocation [must be given
                               as first option!]
   --use-gcc-pipe              Build with GCC option -pipe. Speeds up the build
@@ -80,29 +90,43 @@ options:
   --use-gcc-graphite          Build with GCC Graphite engine for loop
                               optimizations. Only for gcc 4.
   --use-32bit                 Use -m32 flag on 64bit host gcc compiler.
-  --use-xattr                 Use Linux xattr support for BeOS attribute
+  --use-xattr                 Use Linux xattr respectively *BSD extattr support
-                              emulation. Warning: Make sure your file system
+                              for BeOS attribute emulation. Warning: Make sure
-                              supports sufficient attribute sizes (4 KB per
+                              your file system supports sufficient attribute
-                              file for all attributes won't suffice).
+                              sizes (4 KB per file for all attributes won't
+                              suffice).
+  --use-xattr-ref             Use the generic BeOS attribute emulation, but use
+                              Linux xattr respectively *BSD extattr support to
+                              make it more robust (i.e. attribute mix-ups become
+                              less likely).
 
 environment variables:
-  HAIKU_AR                    The static library archiver. Defaults to "ar".
+  HAIKU_AR_x86_gcc2           The static library archiver for x86_gcc2.
-  HAIKU_CC                    The compiler. Defaults to "gcc".
+                              Defaults to "ar".
-  HAIKU_LD                    The linker. Defaults to "ld".
+  HAIKU_CC_x86_gcc2           The x86_gcc2 compiler. Defaults to "gcc".
-  HAIKU_OBJCOPY               The objcopy to be used. Defaults to "objcopy".
+  HAIKU_LD_x86_gcc2           The x86_gcc2 linker. Defaults to "ld".
-  HAIKU_RANLIB                The static library indexer. Defaults to "ranlib".
+  HAIKU_OBJCOPY_x86_gcc2      The x86_gcc2 objcopy to be used. Defaults to
+                              "objcopy".
+  HAIKU_RANLIB_x86_gcc2       The static library indexer for x86_gcc2. Defaults
+                              to "ranlib".
+  HAIKU_STRIP_x86_gcc2        The x86_gcc2 strip command. Defaults to "strip".
   HAIKU_YASM                  The yasm assembler (x86 only).
-  HAIKU_STRIP                 The strip command. Defaults to "strip".
+  HAIKU_CPPFLAGS_<arch>       The preprocessor flags for target architecture
-  HAIKU_CPPFLAGS              The preprocessor flags. Defaults to "".
+                              <arch>. Defaults to "".
-  HAIKU_CCFLAGS               The C flags. Defaults to "".
+  HAIKU_CCFLAGS_<arch>        The C flags for target architecture <arch>.
-  HAIKU_CXXFLAGS              The C++ flags. Defaults to "".
+                              Defaults to "".
-  HAIKU_LDFLAGS               The linker flags. Defaults to "".
+  HAIKU_CXXFLAGS_<arch>       The C++ flags for target architecture <arch>.
-  HAIKU_ARFLAGS               The flags passed to HAIKU_AR for archiving.
+                              Defaults to "".
-                              Defaults to "cru".
+  HAIKU_LDFLAGS_<arch>        The linker flags for target architecture <arch>.
-  HAIKU_UNARFLAGS             The flags passed to HAIKU_AR for unarchiving.
+                              Defaults to "".
-                              Defaults to "x".
+  HAIKU_ARFLAGS_<arch>        The flags passed to HAIKU_AR for target
+                              architecture <arch> for archiving. Defaults to
+                              "cru".
+  HAIKU_UNARFLAGS_<arch>      The flags passed to HAIKU_AR for target
+                              architecture <arch> for unarchiving. Defaults to
+                              "x".
 
-Non-standard output directories:
+Non-default output directories:
   By default all objects, build configuration, and other related files are
   stored in /path/to/haiku_source/generated.  To store objects in a non-default
   location, run "../../relative/path/to/haiku_source/configure <options>" from
@@ -141,6 +165,19 @@ assertparams()
 	fi
 }
 
+# absolute_path
+#
+# returns the absolute path of a given path.
+#
+absolute_path()
+{
+	if [[ "$1" == /* ]]; then
+		echo "$1"
+	else
+		echo "`pwd`/$1"
+	fi
+}
+
 # real_path
 #
 # returns the realpath of a symbolic link.
@@ -156,6 +193,8 @@ real_path()
 #
 standard_gcc_settings()
 {
+	local gcc=$1
+
 	if which greadlink > /dev/null 2>&1; then
 		readlink="greadlink -e"
 	elif which realpath > /dev/null 2>&1; then
@@ -167,61 +206,67 @@ standard_gcc_settings()
 	fi
 
 	# PLATFORM_LINKLIBS
-	gcclib=`$HAIKU_CC -print-libgcc-file-name`
+	local gcclib=`$gcc -print-libgcc-file-name`
-	gccdir=`dirname ${gcclib}`
+	local gccdir=`dirname ${gcclib}`
 
-	HAIKU_GCC_RAW_VERSION=`$HAIKU_CC -dumpversion`
+	local gccRawVersion=`$gcc -dumpversion`
-	HAIKU_GCC_MACHINE=`$HAIKU_CC -dumpmachine`
+	local gccMachine=`$gcc -dumpmachine`
-	if [ "$HAIKU_USE_GCC_GRAPHITE" != 0 ]; then
-		UNUSED=`echo "int main() {}" | $HAIKU_CC -xc -c -floop-block - 2>&1`
-		if [ $? != 0 ]; then
-			echo "GCC Graphite loop optimizations cannot be used"
-			HAIKU_USE_GCC_GRAPHITE=0
-		fi
-	fi
 
-	HAIKU_GCC_LIB_DIR=${gccdir}
+	local libgcc=${gccdir}/libgcc.a
-	HAIKU_GCC_LIBGCC=${gccdir}/libgcc.a
-	HAIKU_GCC_GLUE_CODE="crtbegin.o crtend.o"
-	HAIKU_GCC_HEADERS_DIR="${gccdir}/include
-		${gccdir}/include-fixed"
-	HAIKU_GCC_LIBGCC_OBJECTS=`$HAIKU_AR t ${HAIKU_GCC_LIBGCC} | grep -v eabi.o`
-		# Note: We filter out eabi.o. It's present in gcc's libgcc for PPC and
-		# neither needed nor wanted.
 
-	case $HAIKU_GCC_RAW_VERSION in
+	# determine architecture from machine triple
+	case $gccMachine in
+		arm-*)		targetCpu=arm;;
+		i?86-*)		targetCpu=x86;;
+		m68k-*)		targetCpu=m68k;;
+		mipsel-*)	targetCpu=mipsel;;
+		powerpc-*)	targetCpu=ppc;;
+		x86_64-*)	targetCpu=x86_64;;
+		*)
+			echo "Unsupported gcc target machine: $gccMachine" >&2
+			exit 1
+			;;
+	esac
+
+	local targetArch=$targetCpu
+	local staticLibStdCxx
+	local sharedLibStdCxx
+	local staticLibSupCxx
+	local sharedLibSupCxx
+	local kernelLibgcc
+	local cxxHeaders
+
+	case $gccRawVersion in
 		4.*)
 			# for gcc 4 we use the libstdc++ and libsupc++ that come with the
 			# compiler
-			HAIKU_STATIC_LIBSTDCXX=`$HAIKU_CC -print-file-name=libstdc++.a`
+			staticLibStdCxx=`$gcc -print-file-name=libstdc++.a`
-			HAIKU_SHARED_LIBSTDCXX=`$HAIKU_CC -print-file-name=libstdc++.so`
+			sharedLibStdCxx=`$gcc -print-file-name=libstdc++.so`
-			HAIKU_STATIC_LIBSUPCXX=`$HAIKU_CC -print-file-name=libsupc++.a`
+			staticLibSupCxx=`$gcc -print-file-name=libsupc++.a`
-			HAIKU_SHARED_LIBSUPCXX=`$HAIKU_CC -print-file-name=libsupc++.so`
+			sharedLibSupCxx=`$gcc -print-file-name=libsupc++.so`
 
 			# If the architecture has separate runtime libraries for the
 			# kernel, use them.
-			HAIKU_KERNEL_LIBGCC=`$HAIKU_CC -print-file-name=libgcc-kernel.a`
+			kernelLibgcc=`$gcc -print-file-name=libgcc-kernel.a`
-			if [ $HAIKU_KERNEL_LIBGCC = libgcc-kernel.a ]; then
+			if [ $kernelLibgcc = libgcc-kernel.a ]; then
-				HAIKU_KERNEL_LIBGCC=$HAIKU_GCC_LIBGCC
+				kernelLibgcc=$libgcc
 			fi
-			HAIKU_KERNEL_LIBSUPCXX=`$HAIKU_CC -print-file-name=libsupc++-kernel.a`
+			kernelLibSupCxx=`$gcc -print-file-name=libsupc++-kernel.a`
-			if [ $HAIKU_KERNEL_LIBSUPCXX = libsupc++-kernel.a ]; then
+			if [ $kernelLibSupCxx = libsupc++-kernel.a ]; then
-				HAIKU_KERNEL_LIBSUPCXX=$HAIKU_STATIC_LIBSUPCXX
+				kernelLibSupCxx=$staticLibSupCxx
 			fi
 
-			local headers
+			local headersBase=$gccdir/../../../..
-			if [ -d $gccdir/../../../../$HAIKU_GCC_MACHINE/include/c++/$HAIKU_GCC_RAW_VERSION ]; then
+			local headers=$headersBase/$gccMachine/include/c++/$gccRawVersion
-				headers=$gccdir/../../../../$HAIKU_GCC_MACHINE/include/c++/$HAIKU_GCC_RAW_VERSION
+			if [ ! -d $headers ]; then
-			else
+				headers=$headersBase/include/c++/$gccRawVersion
-				headers=$gccdir/../../../../include/c++/$HAIKU_GCC_RAW_VERSION
 			fi
 
-			HAIKU_CXX_HEADERS_DIR=$headers
+			cxxHeaders=$headers
-			for d in $HAIKU_GCC_MACHINE backward ext; do
+			for d in $gccMachine backward ext; do
 				# Note: We need the line break, otherwise the line might become
 				# too long for jam (512 bytes max).
-				HAIKU_CXX_HEADERS_DIR="$HAIKU_CXX_HEADERS_DIR
+				cxxHeaders="$cxxHeaders $headers/$d"
-					$headers/$d"
 			done
 
 			# Unset the HAIKU_{SHARED,STATIC}_LIB{STD,SUP}CXX variables, if the
@@ -229,55 +274,113 @@ standard_gcc_settings()
 			# symlinks to avoid problems when copying the libraries to the
 			# image.
 
-			if [ $HAIKU_STATIC_LIBSTDCXX = libstdc++.a ]; then
+			if [ $staticLibStdCxx = libstdc++.a ]; then
-				HAIKU_STATIC_LIBSTDCXX=
+				staticLibStdCxx=
 			else
-				HAIKU_STATIC_LIBSTDCXX=`$readlink $HAIKU_STATIC_LIBSTDCXX`
+				staticLibStdCxx=`$readlink $staticLibStdCxx`
 			fi
 
-			if [ $HAIKU_SHARED_LIBSTDCXX = libstdc++.so ]; then
+			if [ $sharedLibStdCxx = libstdc++.so ]; then
-				HAIKU_SHARED_LIBSTDCXX=
+				sharedLibStdCxx=
 			else
-				HAIKU_SHARED_LIBSTDCXX=`$readlink $HAIKU_SHARED_LIBSTDCXX`
+				sharedLibStdCxx=`$readlink $sharedLibStdCxx`
 			fi
 
-			if [ $HAIKU_STATIC_LIBSUPCXX = libsupc++.a ]; then
+			if [ $staticLibSupCxx = libsupc++.a ]; then
-				HAIKU_STATIC_LIBSUPCXX=
+				staticLibSupCxx=
 			else
-				HAIKU_STATIC_LIBSUPCXX=`$readlink $HAIKU_STATIC_LIBSUPCXX`
+				staticLibSupCxx=`$readlink $staticLibSupCxx`
 			fi
 
-			if [ $HAIKU_SHARED_LIBSUPCXX = libsupc++.so ]; then
+			if [ $sharedLibSupCxx = libsupc++.so ]; then
-				HAIKU_SHARED_LIBSUPCXX=
+				sharedLibSupCxx=
 			else
-				HAIKU_SHARED_LIBSUPCXX=`$readlink $HAIKU_SHARED_LIBSUPCXX`
+				sharedLibSupCxx=`$readlink $sharedLibSupCxx`
 			fi
-		;;
+			;;
 		2.9*)
 			# check for correct (most up-to-date) legacy compiler and complain
 			# if an older one is installed
-			if [ $HAIKU_GCC_RAW_VERSION != $haikuRequiredLegacyGCCVersion ]; then
+			if [ $gccRawVersion != $haikuRequiredLegacyGCCVersion ]; then
 				echo "GCC version $haikuRequiredLegacyGCCVersion is required!";
 				echo "Please download it from www.haiku-os.org...";
 				exit 1;
 			fi
 
-			HAIKU_KERNEL_LIBGCC=$HAIKU_GCC_LIBGCC
+			kernelLibgcc=$libgcc
-			HAIKU_KERNEL_LIBSUPCXX=
+			kernelLibSupCxx=
-		;;
+			targetArch=x86_gcc2
+			;;
 	esac
 
-	case $HAIKU_GCC_MACHINE in
+	local bootLibgcc
+	local bootLibSupCxx
+	case $gccMachine in
 		x86_64-*)
 			# Boot loader is 32-bit, need the 32-bit libs.
-			HAIKU_BOOT_LIBGCC=`$HAIKU_CC -m32 -print-libgcc-file-name`
+			bootLibgcc=`$gcc -m32 -print-libgcc-file-name`
-			HAIKU_BOOT_LIBSUPCXX=`$HAIKU_CC -m32 -print-file-name=libsupc++.a`
+			bootLibSupCxx=`$gcc -m32 -print-file-name=libsupc++.a`
-		;;
+			;;
 		*)
-			HAIKU_BOOT_LIBGCC=$HAIKU_GCC_LIBGCC
+			bootLibgcc=$libgcc
-			HAIKU_BOOT_LIBSUPCXX=$HAIKU_STATIC_LIBSUPCXX
+			bootLibSupCxx=$staticLibSupCxx
-		;;
+			;;
 	esac
+
+	# determine whether graphite loop optimization should/can be used
+	local useGraphite=`get_variable HAIKU_USE_GCC_GRAPHITE_$targetCpu`
+	if [ -z "$useGraphite" ]; then
+		useGraphite=$useGccGraphiteDefault
+	fi
+
+	if [ "$useGraphite" != 0 ]; then
+		UNUSED=`echo "int main() {}" | $gcc -xc -c -floop-block - 2>&1`
+		if [ $? != 0 ]; then
+			echo "GCC Graphite loop optimizations cannot be used on $targetArch"
+			useGraphite=0
+		fi
+	fi
+
+	set_variable HAIKU_CPU_$targetArch $targetCpu
+
+	get_build_tool_path CC_$targetArch "$gcc"
+	set_variable HAIKU_GCC_RAW_VERSION_$targetArch $gccRawVersion
+	set_variable HAIKU_GCC_MACHINE_$targetArch $gccMachine
+	set_variable HAIKU_GCC_LIB_DIR_$targetArch $gccdir
+	set_variable HAIKU_GCC_LIBGCC_$targetArch $libgcc
+	set_variable HAIKU_GCC_GLUE_CODE_$targetArch "crtbegin.o crtend.o"
+	set_variable HAIKU_GCC_HEADERS_DIR_$targetArch \
+		"${gccdir}/include ${gccdir}/include-fixed"
+	set_variable HAIKU_STATIC_LIBSTDCXX_$targetArch "$staticLibStdCxx"
+	set_variable HAIKU_SHARED_LIBSTDCXX_$targetArch "$sharedLibStdCxx"
+	set_variable HAIKU_STATIC_LIBSUPCXX_$targetArch "$staticLibSupCxx"
+	set_variable HAIKU_SHARED_LIBSUPCXX_$targetArch "$sharedLibSupCxx"
+	set_variable HAIKU_KERNEL_LIBSUPCXX_$targetArch "$kernelLibSupCxx"
+	set_variable HAIKU_BOOT_LIBSUPCXX_$targetArch "$bootLibSupCxx"
+	set_variable HAIKU_KERNEL_LIBGCC_$targetArch $kernelLibgcc
+	set_variable HAIKU_CXX_HEADERS_DIR_$targetArch "$cxxHeaders"
+	set_variable HAIKU_BOOT_LIBGCC_$targetArch $bootLibgcc
+	set_variable HAIKU_USE_GCC_GRAPHITE_$targetArch $useGraphite
+
+	standard_gcc_settings_targetArch=$targetArch
+}
+
+# set_variable
+#
+# Set the value of a variable.
+#
+set_variable()
+{
+	eval "$1=\"$2\""
+}
+
+# get_variable
+#
+# Echo the value of a variable.
+#
+get_variable()
+{
+	eval "echo \${$1}"
 }
 
 # set_default_value
@@ -296,8 +399,7 @@ set_default_value()
 get_build_tool_path()
 {
 	local var="HAIKU_$1"
-	local tool=$2
+	local path=$2
-	local path="${crossToolsPrefix}$tool"
 
 	if [ -f "$path" ]; then
 		# get absolute path
@@ -315,6 +417,17 @@ get_build_tool_path()
 	eval "$var=$path"
 }
 
+is_in_list()
+{
+	local element
+	for element in $2; do
+		if [ "$1" = "$element" ]; then
+			return 0
+		fi
+	done
+	return 1
+}
+
 # get cwd and the source directory
 currentDir=`pwd`
 cd `dirname "$0"`
@@ -328,22 +441,16 @@ configureArgs="$@"
 #
 platform=`uname`
 platformMachine=`uname  -m`
-targetArch=x86
+targetArchs=
-crossToolsPrefix=
 buildCrossTools=
 buildCrossToolsScript="$sourceDir/build/scripts/build_cross_tools"
-buildCrossToolsMachine=
 buildCrossToolsJobs=
+useGccGraphiteDefault=0
+unknownArchIndex=1
+haikuTargetArchs=
 
 # exported (BuildSetup) default parameter values
 #
-HAIKU_GCC_RAW_VERSION=
-HAIKU_GCC_MACHINE=i586-pc-haiku
-HAIKU_STATIC_LIBSTDCXX=
-HAIKU_SHARED_LIBSTDCXX=
-HAIKU_STATIC_LIBSUPCXX=
-HAIKU_SHARED_LIBSUPCXX=
-HAIKU_CXX_HEADERS_DIR=
 HOST_GCC_RAW_VERSION=`gcc -dumpversion`
 HOST_GCC_MACHINE=`gcc -dumpmachine`
 HAIKU_INCLUDE_GPL_ADDONS=0
@@ -354,34 +461,44 @@ HAIKU_ENABLE_MULTIUSER=0
 HAIKU_DISTRO_COMPATIBILITY=default
 TARGET_PLATFORM=haiku
 HAIKU_USE_GCC_PIPE=0
-HAIKU_USE_GCC_GRAPHITE=0
 HAIKU_HOST_USE_32BIT=0
 HAIKU_HOST_USE_XATTR=0
-HAIKU_ALTERNATIVE_GCC_OUTPUT_DIR=
+HAIKU_HOST_USE_XATTR_REF=0
-HAIKU_ADD_ALTERNATIVE_GCC_LIBS=0
+HAIKU_HOST_BUILD_ONLY=0
 HOST_GCC_LD=`gcc -print-prog-name=ld`
 HOST_GCC_OBJCOPY=`gcc -print-prog-name=objcopy`
 SFDISK_BINARY=sfdisk
 HOST_SFDISK=$SFDISK_BINARY
+HOST_SHA256=
+HOST_HAIKU_PORTER=
+HAIKU_PORTS=
+HAIKU_PORTS_CROSS=
 
-haikuRequiredLegacyGCCVersion="2.95.3-haiku-121101"
+HAIKU_PACKAGING_ARCHS=
+
+set_default_value HAIKU_YASM		yasm
+
+if sha256sum < /dev/null > /dev/null 2>&1; then
+	HOST_SHA256=sha256sum
+elif sha256 < /dev/null > /dev/null 2>&1; then
+	HOST_SHA256="sha256 -q"
+else
+	echo "Error: Neither sha256sum nor sha256 seem to be available!" >&2
+	exit 1
+fi
+
+haikuRequiredLegacyGCCVersion="2.95.3-haiku-2013_08_15"
 export haikuRequiredLegacyGCCVersion
 	# version of legacy gcc required to build haiku
-
+supportedTargetArchs="
-set_default_value HAIKU_AR			ar
+	arm
-set_default_value HAIKU_CC			gcc
+	m68k
-set_default_value HAIKU_LD			ld
+	mipsel
-set_default_value HAIKU_OBJCOPY		objcopy
+	ppc
-set_default_value HAIKU_RANLIB		ranlib
+	x86
-set_default_value HAIKU_ELFEDIT		elfedit
+	x86_64
-set_default_value HAIKU_YASM		yasm
+	x86_gcc2
-set_default_value HAIKU_STRIP		strip
+	"
-set_default_value HAIKU_CPPFLAGS	""
-set_default_value HAIKU_CCFLAGS		""
-set_default_value HAIKU_CXXFLAGS	""
-set_default_value HAIKU_LDFLAGS		""
-set_default_value HAIKU_ARFLAGS		cru
-set_default_value HAIKU_UNARFLAGS	x
 
 # determine output directory
 if [ "$currentDir" = "$sourceDir" ]; then
@@ -416,35 +533,48 @@ fi
 #
 while [ $# -gt 0 ] ; do
 	case "$1" in
-		--alternative-gcc-output-dir)
+		--bootstrap)
-			assertparam "$1" $#
+			assertparams "$1" 3 $#
-			cd $2 || exit 1
+			HOST_HAIKU_PORTER="`absolute_path $2`"
-			HAIKU_ALTERNATIVE_GCC_OUTPUT_DIR=`pwd`
+			HAIKU_PORTS_CROSS="`absolute_path $3`"
-			HAIKU_ADD_ALTERNATIVE_GCC_LIBS=1
+			HAIKU_PORTS="`absolute_path $4`"
-			cd $currentDir
+			shift 4
-			shift 2
 			;;
-		--build-cross-tools) assertparam "$1" $#; buildCrossTools=$2; shift 2;;
+		--build-cross-tools)
-		--build-cross-tools-gcc4)
+			if [ -z "$buildCrossTools" ]; then
-			assertparams "$1" 2 $#
+				assertparams "$1" 2 $#
-			buildCrossTools=$3
+				targetArch=$2
-			buildCrossToolsScript="${buildCrossToolsScript}_gcc4"
+				buildCrossTools=$3
-			case "$2" in
+				shift 3
-				x86)	HAIKU_GCC_MACHINE=i586-pc-haiku;;
+			else
-				x86_64)	HAIKU_GCC_MACHINE=x86_64-unknown-haiku; targetArch=x86_64;;
+				assertparam "$1" $#
-				ppc)	HAIKU_GCC_MACHINE=powerpc-apple-haiku; targetArch=ppc;;
+				targetArch=$2
-				m68k)	HAIKU_GCC_MACHINE=m68k-unknown-haiku; targetArch=m68k;;
+				shift 2
-				arm)	HAIKU_GCC_MACHINE=arm-unknown-haiku; targetArch=arm;;
+			fi
-				mipsel)	HAIKU_GCC_MACHINE=mipsel-unknown-haiku; targetArch=mips;;
+			case "$targetArch" in
-				*)		echo "Unsupported target architecture: $2"
+				x86_gcc2)	targetMachine=i586-pc-haiku;;
-						exit 1;;
+				x86)		targetMachine=i586-pc-haiku;;
+				x86_64)		targetMachine=x86_64-unknown-haiku;;
+				ppc)		targetMachine=powerpc-apple-haiku;;
+				m68k)		targetMachine=m68k-unknown-haiku;;
+				arm)		targetMachine=arm-unknown-haiku;;
+				mipsel)		targetMachine=mipsel-unknown-haiku;;
+				*)
+					echo "Unsupported target architecture: $2" >&2
+					exit 1
+					;;
 			esac
-			buildCrossToolsMachine=$HAIKU_GCC_MACHINE
+			set_variable buildCrossToolsMachine_$targetArch $targetMachine
-			shift 3
+			targetArchs="$targetArchs $targetArch"
+			HAIKU_PACKAGING_ARCHS=
 			;;
 		--cross-tools-prefix)
 			assertparam "$1" $#
-			crossToolsPrefix=$2
+			targetArch=unknown${unknownArchIndex}
+			set_variable crossToolsPrefix_$targetArch "$2"
+			targetArchs="$targetArchs $targetArch"
+			HAIKU_PACKAGING_ARCHS=
+			unknownArchIndex=$(($unknownArchIndex + 1))
 			shift 2
 			;;
 		--distro-compatibility)
@@ -462,32 +592,38 @@ while [ $# -gt 0 ] ; do
 			;;
 		--enable-multiuser)	HAIKU_ENABLE_MULTIUSER=1; shift 1;;
 		--help | -h)	usage; exit 0;;
+		--host-only)	HAIKU_HOST_BUILD_ONLY=1; shift 1;;
 		--include-gpl-addons)	HAIKU_INCLUDE_GPL_ADDONS=1; shift 1;;
 		--include-patented-code)	HAIKU_INCLUDE_PATENTED_CODE=1; shift 1;;
 		--include-sources)	HAIKU_INCLUDE_SOURCES=1; shift 1;;
 		--include-3rdparty)	HAIKU_INCLUDE_3RDPARTY=1; shift 1;;
         -j*)				buildCrossToolsJobs="$1"; shift 1;;
 		--target=*)     TARGET_PLATFORM=`echo $1 | cut -d'=' -f2-`; shift 1;;
+		--target-arch)
+			assertparam "$1" $#
+			targetArch=$2
+			shift 2
+			if [ ! "$platform" = Haiku ]; then
+				echo "--target-arch can only be specified on Haiku." >&2
+				exit 1
+			fi
+			is_in_list "$targetArch" "$supportedTargetArchs" || (
+				echo "Unsupported target architecture: \"$targetArch\"" >&2
+				exit 1
+			)
+			haikuTargetArchs="$haikuTargetArchs $targetArch"
+			;;
 		--use-gcc-pipe)	HAIKU_USE_GCC_PIPE=1; shift 1;;
-		--use-gcc-graphite)	HAIKU_USE_GCC_GRAPHITE=1; shift 1;;
+		--use-gcc-graphite)	useGccGraphiteDefault=1; shift 1;;
 		--use-32bit)	HAIKU_HOST_USE_32BIT=1; shift 1;;
 		--use-xattr)	HAIKU_HOST_USE_XATTR=1; shift 1;;
+		--use-xattr-ref)	HAIKU_HOST_USE_XATTR_REF=1; shift 1;;
 		*)				echo Invalid argument: \`$1\'; exit 1;;
 	esac
 done
 
 # detect the build platform
 case "${platform}" in
-	BeOS)	revision=`uname -r`
-			case "$revision" in
-				6.*)	HOST_PLATFORM=dano ;;
-				5.1)	HOST_PLATFORM=dano ;;
-				5.0.4)	HOST_PLATFORM=bone ;;
-				5.0*)	HOST_PLATFORM=r5 ;;
-				*)		echo Unknown BeOS version: $revision
-						exit 1 ;;
-			esac
-			;;
 	Darwin)	HOST_PLATFORM=darwin ;;
 	FreeBSD)	HOST_PLATFORM=freebsd
 				SFDISK_BINARY=sfdisk-linux
@@ -528,47 +664,170 @@ fi
 # create output directory
 mkdir -p "$buildOutputDir" || exit 1
 
-# build cross tools from sources
+if [ "$HAIKU_HOST_BUILD_ONLY" = 1 ]; then
-if [ -n "$buildCrossTools" ]; then
+	invalidCommand=$sourceDir/build/scripts/host_build_only
-	export HAIKU_USE_GCC_GRAPHITE
+	HAIKU_AR=$invalidCommand
-	"$buildCrossToolsScript" $buildCrossToolsMachine "$sourceDir" \
+	HAIKU_CC=$invalidCommand
-		"$buildCrossTools" "$outputDir" $buildCrossToolsJobs || exit 1
+	HAIKU_LD=$invalidCommand
-	crossToolsPrefix="$outputDir/cross-tools/bin/${HAIKU_GCC_MACHINE}-"
+	HAIKU_OBJCOPY=$invalidCommand
+	HAIKU_RANLIB=$invalidCommand
+	HAIKU_ELFEDIT=$invalidCommand
+	HAIKU_YASM=$invalidCommand
+	HAIKU_STRIP=$invalidCommand
+else
+	if [ -n "$HAIKU_PACKAGING_ARCHS" ]; then
+		targetArchs="$HAIKU_PACKAGING_ARCHS"
+	fi
+	HAIKU_PACKAGING_ARCHS=
+
+	# On Haiku determine target architectures and tools automatically.
+	if [ -z "$targetArchs" ]; then
+		if [ $HOST_PLATFORM != haiku_host ]; then
+			echo "Please specify the build tools to use or build (via" \
+				"--cross-tools-prefix or --build-cross-tools) or specify a"
+				"host-only build (--host-only)." >&2
+			exit 1
+		fi
+
+		# determine primary architecture
+		targetArch=`package list -i /system/packages/haiku.hpkg \
+			| sed '/^\s*architecture:/!d; s,^\s*architecture:\s*,,'`
+		is_in_list "$targetArch" "$supportedTargetArchs" || (
+			echo "Unsupported target architecture: \"$targetArch\"" >&2
+			exit 1
+		)
+		targetArchs=$targetArch
+
+		set_default_value HAIKU_AR_$targetArch			ar
+		set_default_value HAIKU_CC_$targetArch			gcc
+		set_default_value HAIKU_LD_$targetArch			ld
+		set_default_value HAIKU_OBJCOPY_$targetArch		objcopy
+		set_default_value HAIKU_RANLIB_$targetArch		ranlib
+		set_default_value HAIKU_ELFEDIT_$targetArch		elfedit
+		set_default_value HAIKU_STRIP_$targetArch		strip
+
+		# determine secondary architectures
+		for targetArch in $supportedTargetArchs; do
+			if [ -e /system/packages/haiku_$targetArch.hpkg ]; then
+				targetArchs="$targetArchs $targetArch"
+				set_default_value HAIKU_AR_$targetArch		ar-$targetArch
+				set_default_value HAIKU_CC_$targetArch		gcc-$targetArch
+				set_default_value HAIKU_LD_$targetArch		ld-$targetArch
+				set_default_value HAIKU_OBJCOPY_$targetArch	objcopy-$targetArch
+				set_default_value HAIKU_RANLIB_$targetArch	ranlib-$targetArch
+				set_default_value HAIKU_ELFEDIT_$targetArch	elfedit-$targetArch
+				set_default_value HAIKU_STRIP_$targetArch	strip-$targetArch
+			fi
+		done
+
+		# The target architectures might have been specified explicitly.
+		if [ -n "$haikuTargetArchs" ]; then
+			for targetArch in $haikuTargetArchs; do
+				is_in_list "$targetArch" "$targetArchs" || (
+					echo "Unsupported target architecture: \"$targetArch\"." \
+						"Only native architectures of the host platform can" \
+						"be specified." >&2
+					exit 1
+				)
+			done
+			targetArchs="$haikuTargetArchs"
+		fi
+	fi
+
+	isPrimaryArch=1
+	for targetArch in $targetArchs; do
+		# Note: targetArch is "unknown<n>" at this point, if a cross-tools
+		# prefix was specified. The standard_gcc_settings call below will get
+		# the actual architecture.
+
+		crossToolsPrefix=`get_variable crossToolsPrefix_$targetArch`
+
+		# build cross tools from sources
+		if [ -n "$buildCrossTools" -a -z "$crossToolsPrefix" ]; then
+			crossToolsDir="$outputDir/cross-tools-$targetArch"
+			targetMachine=`get_variable buildCrossToolsMachine_$targetArch`
+			script="$buildCrossToolsScript"
+			if [ $targetArch != x86_gcc2 ]; then
+				script="${script}_gcc4 $targetMachine"
+			fi
+			secondaryArch=
+			if [ -z "$isPrimaryArch" ]; then
+				secondaryArch=$targetArch
+			fi
+
+			case $HOST_PLATFORM in
+				freebsd|openbsd)	MAKE=gmake;;
+				*)					MAKE=make;;
+			esac
+
+			MAKE=$MAKE \
+			SECONDARY_ARCH=$secondaryArch \
+			HAIKU_USE_GCC_GRAPHITE=`get_variable \
+				HAIKU_USE_GCC_GRAPHITE_$targetArch` \
+			$script "$sourceDir" "$buildCrossTools" "$crossToolsDir" \
+				$buildCrossToolsJobs || exit 1
+			crossToolsPrefix="$crossToolsDir/bin/${targetMachine}-"
+		fi
+
+		# prepare gcc settings and get the actual target architecture
+		gcc="${crossToolsPrefix}gcc"
+		if [ -z "${crossToolsPrefix}" ]; then
+			gcc=`get_variable HAIKU_CC_$targetArch`
+		fi
+		standard_gcc_settings "$gcc"
+		targetArch=$standard_gcc_settings_targetArch
+
+		# set default values for flags
+		set_default_value HAIKU_CPPFLAGS_$targetArch	""
+		set_default_value HAIKU_CCFLAGS_$targetArch		""
+		set_default_value HAIKU_CXXFLAGS_$targetArch	""
+		set_default_value HAIKU_LDFLAGS_$targetArch		""
+		set_default_value HAIKU_ARFLAGS_$targetArch		cru
+		set_default_value HAIKU_UNARFLAGS_$targetArch	x
+
+		# Override the cross tools variables, if the tools were built or a
+		# prefix was specified.
+		if [ -n "$crossToolsPrefix" ]; then
+			get_build_tool_path AR_$targetArch ${crossToolsPrefix}ar
+			get_build_tool_path LD_$targetArch ${crossToolsPrefix}ld
+			get_build_tool_path OBJCOPY_$targetArch ${crossToolsPrefix}objcopy
+			get_build_tool_path RANLIB_$targetArch ${crossToolsPrefix}ranlib
+			get_build_tool_path STRIP_$targetArch ${crossToolsPrefix}strip
+
+			case `get_variable HAIKU_GCC_RAW_VERSION_$targetArch` in
+				4.*)
+					get_build_tool_path ELFEDIT_$targetArch \
+						${crossToolsPrefix}elfedit
+				;;
+			esac
+		fi
+
+		# Get the libgcc objects. We couldn't do that in standard_gcc_settings,
+		# since we need "ar", which may be set later.
+		ar=`get_variable HAIKU_AR_$targetArch`
+		libgcc=`get_variable HAIKU_GCC_LIBGCC_$targetArch`
+		set_variable HAIKU_GCC_LIBGCC_OBJECTS_$targetArch \
+			"`$ar t $libgcc | grep -v eabi.o`"
+			# Note: We filter out eabi.o. It's present in gcc's libgcc for PPC
+			# and neither needed nor wanted.
+
+		# check whether the Haiku compiler really targets Haiku
+		targetMachine=`get_variable HAIKU_GCC_MACHINE_$targetArch`
+		case "$targetMachine" in
+			*-*-haiku)	;;
+			*)
+				echo The compiler specified as Haiku target compiler is not a \
+				valid Haiku cross-compiler. Please see ReadMe.cross-compile. >&2
+				echo compiler: $HAIKU_CC
+				echo compiler is configured for target: $targetMachine
+				exit 1 ;;
+		esac
+
+		HAIKU_PACKAGING_ARCHS="$HAIKU_PACKAGING_ARCHS $targetArch"
+		isPrimaryArch=
+	done
 fi
 
-# cross tools
-if [ -n "$crossToolsPrefix" ]; then
-	get_build_tool_path AR ar
-	get_build_tool_path CC gcc
-	get_build_tool_path LD ld
-	get_build_tool_path OBJCOPY objcopy
-	get_build_tool_path RANLIB ranlib
-	get_build_tool_path STRIP strip
-fi
-
-# prepare gcc settings
-standard_gcc_settings
-
-# cross tools for gcc4 builds
-if [ -n "$crossToolsPrefix" ]; then
-	case $HAIKU_GCC_RAW_VERSION in
-		4.*)
-			get_build_tool_path ELFEDIT elfedit
-		;;
-	esac
-fi
-
-# check whether the Haiku compiler really targets Haiku or BeOS
-case "$HAIKU_GCC_MACHINE" in
-	*-*-haiku)	;;
-	*-*-beos)	;;
-	*) echo The compiler specified as Haiku target compiler is not a valid \
-			Haiku cross-compiler. Please see ReadMe.cross-compile. >&2
-	   echo compiler: $HAIKU_CC
-	   echo compiler is configured for target: $HAIKU_GCC_MACHINE
-	   exit 1 ;;
-esac
-
 # Generate BuildConfig
 cat << EOF > "$buildConfigFile"
 # BuildConfig
@@ -586,62 +845,84 @@ HAIKU_INCLUDE_3RDPARTY				?= "${HAIKU_INCLUDE_3RDPARTY}" ;
 HAIKU_ENABLE_MULTIUSER				?= "${HAIKU_ENABLE_MULTIUSER}" ;
 HAIKU_DISTRO_COMPATIBILITY			?= "${HAIKU_DISTRO_COMPATIBILITY}" ;
 HAIKU_USE_GCC_PIPE					?= "${HAIKU_USE_GCC_PIPE}" ;
-HAIKU_USE_GCC_GRAPHITE				?= "${HAIKU_USE_GCC_GRAPHITE}" ;
 HAIKU_HOST_USE_32BIT				?= "${HAIKU_HOST_USE_32BIT}" ;
 HAIKU_HOST_USE_XATTR				?= "${HAIKU_HOST_USE_XATTR}" ;
-HAIKU_ALTERNATIVE_GCC_OUTPUT_DIR	?= ${HAIKU_ALTERNATIVE_GCC_OUTPUT_DIR} ;
+HAIKU_HOST_USE_XATTR_REF			?= "${HAIKU_HOST_USE_XATTR_REF}" ;
-HAIKU_ADD_ALTERNATIVE_GCC_LIBS		?= ${HAIKU_ADD_ALTERNATIVE_GCC_LIBS} ;
+HAIKU_HOST_BUILD_ONLY				?= "${HAIKU_HOST_BUILD_ONLY}" ;
 
-HAIKU_GCC_RAW_VERSION		?= ${HAIKU_GCC_RAW_VERSION} ;
+HAIKU_PACKAGING_ARCHS		?= ${HAIKU_PACKAGING_ARCHS} ;
-HAIKU_GCC_MACHINE			?= ${HAIKU_GCC_MACHINE} ;
-HAIKU_GCC_LIB_DIR			?= ${HAIKU_GCC_LIB_DIR} ;
-HAIKU_GCC_HEADERS_DIR		?= ${HAIKU_GCC_HEADERS_DIR} ;
-HAIKU_GCC_LIBGCC			?= ${HAIKU_GCC_LIBGCC} ;
-
-HAIKU_STATIC_LIBSTDC++		?= ${HAIKU_STATIC_LIBSTDCXX} ;
-HAIKU_SHARED_LIBSTDC++		?= ${HAIKU_SHARED_LIBSTDCXX} ;
-HAIKU_STATIC_LIBSUPC++		?= ${HAIKU_STATIC_LIBSUPCXX} ;
-HAIKU_SHARED_LIBSUPC++		?= ${HAIKU_SHARED_LIBSUPCXX} ;
-HAIKU_C++_HEADERS_DIR		?= ${HAIKU_CXX_HEADERS_DIR} ;
-
-HAIKU_KERNEL_LIBGCC			?= ${HAIKU_KERNEL_LIBGCC} ;
-HAIKU_KERNEL_LIBSUPC++		?= ${HAIKU_KERNEL_LIBSUPCXX} ;
-HAIKU_BOOT_LIBGCC			?= ${HAIKU_BOOT_LIBGCC} ;
-HAIKU_BOOT_LIBSUPC++		?= ${HAIKU_BOOT_LIBSUPCXX} ;
 
 HAIKU_BUILD_ATTRIBUTES_DIR	?= ${HAIKU_BUILD_ATTRIBUTES_DIR} ;
 
-HAIKU_AR					?= ${HAIKU_AR} ;
-HAIKU_CC					?= ${HAIKU_CC} ;
-HAIKU_LD					?= ${HAIKU_LD} ;
-HAIKU_OBJCOPY				?= ${HAIKU_OBJCOPY} ;
-HAIKU_RANLIB				?= ${HAIKU_RANLIB} ;
-HAIKU_ELFEDIT				?= ${HAIKU_ELFEDIT} ;
 HAIKU_YASM					?= ${HAIKU_YASM} ;
-HAIKU_STRIP					?= ${HAIKU_STRIP} ;
-HAIKU_CPPFLAGS				?= ${HAIKU_CPPFLAGS} ;
-HAIKU_CCFLAGS				?= ${HAIKU_CCFLAGS} ;
-HAIKU_C++FLAGS				?= ${HAIKU_CXXFLAGS} ;
-HAIKU_LDFLAGS				?= ${HAIKU_LDFLAGS} ;
-HAIKU_ARFLAGS				?= ${HAIKU_ARFLAGS} ;
-HAIKU_UNARFLAGS				?= ${HAIKU_UNARFLAGS} ;
 
 HOST_GCC_RAW_VERSION		?= ${HOST_GCC_RAW_VERSION} ;
 HOST_GCC_MACHINE			?= ${HOST_GCC_MACHINE} ;
 HOST_LD						?= ${HOST_GCC_LD} ;
 HOST_OBJCOPY				?= ${HOST_GCC_OBJCOPY} ;
 HOST_SFDISK					?= ${HOST_SFDISK} ;
+HOST_SHA256					?= ${HOST_SHA256} ;
+
+HOST_HAIKU_PORTER			?= ${HOST_HAIKU_PORTER} ;
+HAIKU_PORTS					?= ${HAIKU_PORTS} ;
+HAIKU_PORTS_CROSS			?= ${HAIKU_PORTS_CROSS} ;
 
 EOF
 
-# Libgcc.a objects
+for targetArch in $HAIKU_PACKAGING_ARCHS; do
+	variables="
+		HAIKU_GCC_RAW_VERSION		HAIKU_GCC_RAW_VERSION
+		HAIKU_GCC_MACHINE			HAIKU_GCC_MACHINE
+		HAIKU_GCC_LIB_DIR			HAIKU_GCC_LIB_DIR
+		HAIKU_GCC_LIBGCC			HAIKU_GCC_LIBGCC
+		HAIKU_CPU					HAIKU_CPU
+		HAIKU_STATIC_LIBSTDC++		HAIKU_STATIC_LIBSTDCXX
+		HAIKU_SHARED_LIBSTDC++		HAIKU_SHARED_LIBSTDCXX
+		HAIKU_STATIC_LIBSUPC++		HAIKU_STATIC_LIBSUPCXX
+		HAIKU_SHARED_LIBSUPC++		HAIKU_SHARED_LIBSUPCXX
+		HAIKU_KERNEL_LIBGCC			HAIKU_KERNEL_LIBGCC
+		HAIKU_KERNEL_LIBSUPC++		HAIKU_KERNEL_LIBSUPCXX
+		HAIKU_BOOT_LIBGCC			HAIKU_BOOT_LIBGCC
+		HAIKU_BOOT_LIBSUPC++		HAIKU_BOOT_LIBSUPCXX
+		HAIKU_AR					HAIKU_AR
+		HAIKU_CC					HAIKU_CC
+		HAIKU_LD					HAIKU_LD
+		HAIKU_OBJCOPY				HAIKU_OBJCOPY
+		HAIKU_RANLIB				HAIKU_RANLIB
+		HAIKU_ELFEDIT				HAIKU_ELFEDIT
+		HAIKU_STRIP					HAIKU_STRIP
+		HAIKU_CPPFLAGS				HAIKU_CPPFLAGS
+		HAIKU_CCFLAGS				HAIKU_CCFLAGS
+		HAIKU_C++FLAGS				HAIKU_CXXFLAGS
+		HAIKU_LDFLAGS				HAIKU_LDFLAGS
+		HAIKU_ARFLAGS				HAIKU_ARFLAGS
+		HAIKU_UNARFLAGS				HAIKU_UNARFLAGS
+		HAIKU_USE_GCC_GRAPHITE		HAIKU_USE_GCC_GRAPHITE
+		"
+	set -- $variables
+	while [ $# -ge 2 ]; do
+		value=`get_variable ${2}_$targetArch`
+		echo "${1}_${targetArch} ?= $value ;" >> "$buildConfigFile"
+		shift 2
+	done
 
-cat << EOF > "$buildOutputDir/libgccObjects"
+	# For variables that may have long values, distribute them over multiple
-# libgcc.a objects to be linked against libroot.so
+	# lines so that jam doesn't hit the maximum line length.
-# Note: This file has been automatically generated by configure.
+	variables="
+		HAIKU_GCC_HEADERS_DIR		HAIKU_GCC_HEADERS_DIR
+		HAIKU_C++_HEADERS_DIR		HAIKU_CXX_HEADERS_DIR
+		HAIKU_GCC_LIBGCC_OBJECTS	HAIKU_GCC_LIBGCC_OBJECTS
+		"
+	set -- $variables
+	while [ $# -ge 2 ]; do
+		echo "${1}_${targetArch} ?= " >> "$buildConfigFile"
+		get_variable ${2}_$targetArch | xargs -n 1 echo "   " \
+			>> "$buildConfigFile"
+		echo "    ;" >> "$buildConfigFile"
+		shift 2
+	done
+done
 
-HAIKU_GCC_LIBGCC_OBJECTS	?= ${HAIKU_GCC_LIBGCC_OBJECTS} ;
-EOF
 
 # Generate a boot strap Jamfile in the output directory.
 

data/bin/freetype-config

@@ -1,160 +0,0 @@
-#! /bin/sh
-#
-# Copyright 2000, 2001, 2002, 2003, 2004, 2005, 2008, 2009 by
-# David Turner, Robert Wilhelm, and Werner Lemberg.
-#
-# This file is part of the FreeType project, and may only be used, modified,
-# and distributed under the terms of the FreeType project license,
-# LICENSE.TXT.  By continuing to use, modify, or distribute this file you
-# indicate that you have read the license and understand and accept it
-# fully.
-
-prefix=/boot/common
-exec_prefix=${prefix}
-exec_prefix_set=no
-includedir=/boot/develop/headers/3rdparty
-libdir=${exec_prefix}/lib
-enable_shared=
-wl=-Wl,
-hardcode_libdir_flag_spec='${wl}-rpath ${wl}$libdir'
-
-usage()
-{
-  cat <<EOF
-Usage: freetype-config [OPTION]...
-Get FreeType compilation and linking information.
-
-Options:
-  --prefix               display \`--prefix' value used for building the
-                         FreeType library
-  --prefix=PREFIX        override \`--prefix' value with PREFIX
-  --exec-prefix          display \`--exec-prefix' value used for building
-                         the FreeType library
-  --exec-prefix=EPREFIX  override \`--exec-prefix' value with EPREFIX
-  --version              display libtool version of the FreeType library
-  --ftversion            display FreeType version number
-  --libs                 display flags for linking with the FreeType library
-  --libtool              display library name for linking with libtool
-  --cflags               display flags for compiling with the FreeType
-                         library
-EOF
-  exit $1
-}
-
-if test $# -eq 0 ; then
-  usage 1 1>&2
-fi
-
-while test $# -gt 0 ; do
-  case "$1" in
-  -*=*)
-    optarg=`echo "$1" | sed 's/[-_a-zA-Z0-9]*=//'`
-    ;;
-  *)
-    optarg=
-    ;;
-  esac
-
-  case $1 in
-  --prefix=*)
-    prefix=$optarg
-    local_prefix=yes
-    ;;
-  --prefix)
-    echo_prefix=yes
-    ;;
-  --exec-prefix=*)
-    exec_prefix=$optarg
-    exec_prefix_set=yes
-    local_prefix=yes
-    ;;
-  --exec-prefix)
-    echo_exec_prefix=yes
-    ;;
-  --version)
-    echo 9.20.3
-    exit 0
-    ;;
-  --ftversion)
-    echo_ft_version=yes
-    ;;
-  --cflags)
-    echo_cflags=yes
-    ;;
-  --libs)
-    echo_libs=yes
-    ;;
-  --libtool)
-    echo_libtool=yes
-    ;;
-  *)
-    usage 1 1>&2
-    ;;
-  esac
-  shift
-done
-
-if test "$local_prefix" = "yes" ; then
-  if test "$exec_prefix_set" != "yes" ; then
-    exec_prefix=$prefix
-  fi
-fi
-
-if test "$echo_prefix" = "yes" ; then
-  echo $prefix
-fi
-
-if test "$echo_exec_prefix" = "yes" ; then
-  echo $exec_prefix
-fi
-
-if test "$exec_prefix_set" = "yes" ; then
-  libdir=$exec_prefix/lib
-else
-  if test "$local_prefix" = "yes" ; then
-    includedir=$prefix/include
-    libdir=$prefix/lib
-  fi
-fi
-
-if test "$echo_ft_version" = "yes" ; then
-  major=`grep define $includedir/freetype/freetype.h \
-         | grep FREETYPE_MAJOR \
-         | sed 's/.*[ 	]\([0-9][0-9]*\).*/\1/'`
-  minor=`grep define $includedir/freetype/freetype.h \
-         | grep FREETYPE_MINOR \
-         | sed 's/.*[ 	]\([0-9][0-9]*\).*/\1/'`
-  patch=`grep define $includedir/freetype/freetype.h \
-         | grep FREETYPE_PATCH \
-         | sed 's/.*[ 	]\([0-9][0-9]*\).*/\1/'`
-  echo $major.$minor.$patch
-fi
-
-if test "$echo_cflags" = "yes" ; then
-  cflags="-I$includedir/freetype2"
-  if test "$includedir" != "/usr/include" ; then
-    echo $cflags -I$includedir
-  else
-    echo $cflags
-  fi
-fi
-
-if test "$echo_libs" = "yes" ; then
-  rpath=
-  if test "$enable_shared" = "yes" ; then
-    eval "rpath=\"$hardcode_libdir_flag_spec\""
-  fi
-  libs="-lfreetype -lz "
-  if test "$libdir" != "/usr/lib" && test "$libdir" != "/usr/lib64"; then
-    echo -L$libdir $rpath $libs
-  else
-    echo $libs
-  fi
-fi
-
-if test "$echo_libtool" = "yes" ; then
-  convlib="libfreetype.la"
-  echo $libdir/$convlib
-fi
-
-# EOF

data/bin/installoptionalpackage

@@ -1,962 +0,0 @@
-#!/bin/bash
-#
-# Copyright (c) 2009-2010 Haiku, Inc.
-# Distributed under the terms of the MIT License.
-#
-# Authors:
-#		Matt Madia, [email protected]
-#
-# Synopsis:
-#	Provides a controlled mechanism for end-users to install certain pre-built
-#	OptionalPackages. The script will determine the host information: the
-#	default GCC, availability of secondary GCC libs, and revision. Using this
-#	information, the user will be limited to the appropriate OptionalPackages
-#	that were available for that specific revision.
-#
-DISCLAIMER="\
-Disclaimer:\n\
-  This is a temporary solution for installing OptionalPackages.\n\
-  In time, there will be an official package manager.\n\
-  See these URL's for information on the in-development package manager.\n\
-    http://dev.haiku-os.org/wiki/PackageManagerIdeas\n\
-    http://dev.haiku-os.org/wiki/PackageFormat\n\
-	"
-
-USAGE="\
-Usage: ./installoptionalpackage [<pkg> [<pkg> ...]]\n\
-  or   ./installoptionalpackage [-a|-s <pkg> [<pkg> ...]]\n\
-  or   ./installoptionalpackage [-f|-h|-l]\n\
-\n\
-Options:\n\
--a     Add one or more packages and all dependencies\n\
--s     Show the final list of packages that would be installed\n\
--f     Remove cached data and list installable packages\n\
--h     Print this help.\n\
--l     List installable packages\n\
-	"
-
-declare -A availablePackages
-declare availablePackagesKeys=""
-declare wantsToInstall=""
-declare alreadyInstalled=""
-# Some Packages cannot be installed,
-# as they require either the source code or compiled binaries
-declare packageIgnoreList="Bluetooth Development DevelopmentMin \
-DevelopmentBase ICU-devel ICU MandatoryPackages UserlandFS \
-WebPositive Welcome WifiFirmwareScriptData "
-
-
-function CreateInstallerScript()
-{
-	# This function will create a secondary script, containing all of the
-	# information needed to install the optional package and its dependencies
-
-#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-	cat << EOF > ${tmpDir}/install-optpkg.sh
-#!/bin/bash
-
-tmpDir=${tmpDir}
-HAIKU_GCC_VERSION[1]=${HAIKU_GCC_VERSION[1]}
-isHybridBuild=${isHybridBuild}
-TARGET_ARCH=${TARGET_ARCH}
-HAIKU_IMAGE_HOST_NAME=`uname -n`
-#TODO: possibly add a CLI option to execute InstallSourceArchive
-HAIKU_INCLUDE_SOURCES=0
-$urlLine
-$sslPkgLine
-$sslUrlLine
-$webkitFileLine
-declare -a functionArgs
-expanderRulesFile=`finddir B_COMMON_DATA_DIRECTORY`/expander.rules
-if [ -f \${expanderRulesFile} ] ; then
-	expanderRulesFileExists=1
-fi
-
-
-function ParseFunctionArguments()
-{
-	# ParseFunctionArguments <args>
-	# Parse arguments for Jam wrapper functions into an array.
-	IN="\$@"
-	OIFS=\$IFS
-	IFS=":"
-
-	local count=0
-	functionArgs=( )
-	for x in \$IN
-	do
-		functionArgs[\${count}]="\${x}"
-		((count++))
-	done
-	IFS=\$OIFS
-}
-
-
-function TrimLeadingSpace()
-{
-	# TrimLeadingSpace <variable name>
-	eval local text='\$'"\$1"
-	local _outvar="\$1"
-
-	local length=\${#text}
-	((length--))
-	if [ "\${text:0:1}" == ' ' ] ; then
-		text=\${text#' '}
-	fi
-
-	eval \$_outvar="'\$text'"
-}
-
-
-function TrimEndingSpace()
-{
-	# TrimEndingSpace <variable name>
-	eval local text='\$'"\$1"
-	local _outvar="\$1"
-
-	local length=\${#text}
-	((length--))
-	if [ "\${text:\$length}" == ' ' ] ; then
-		text=\${text%' '}
-	fi
-
-	eval \$_outvar="'\$text'"
-}
-
-
-function Exit()
-{
-	# Exit <message>
-	# Wrapper for Jam rule
-	echo "\$@"
-	exit 1
-}
-
-
-function InstallOptionalHaikuImagePackage()
-{
-	# InstallOptionalHaikuImagePackage package : url : dirTokens : isCDPackage
-
-	# Wrapper for Jam rule
-	echo "Installing \$1 ..."
-	cd \$tmpDir
-
-	archiveFile=\`echo \$3 | sed -s "s/http.*\///"\`
-	if ! [ -f \$archiveFile ] ; then
-		echo "Downloading \$3 ..."
-		# TODO : add some error handling for downloads
-		local attempt=1
-		while [ \`wget -nv \$3 ; echo \$? \` -ne 0 ]; do
-			if [ \$attempt -eq 5 ]; then
-				break
-			fi
-			(( attempt++ ))
-			echo "Download attempt #\$attempt failed. Retrying ..."
-			if [ -e \$archiveFile ]; then
-				rm \$archiveFile
-			fi
-		done
-		if [ \$attempt -ge 5 ]; then
-			if [ -e \$archiveFile ]; then
-				rm \$archiveFile
-			fi
-			Exit "Max download retries exceeded. Halting installation."
-		fi
-	fi
-
-	local dirTokens='/boot'
-	local count=4
-	local i=0
-	for possibleToken in "\$@" ; do
-		if [ \$i -lt \$count ] ; then
-			((i++))
-		else
-			((i++))
-			if [ "\$possibleToken" != ':' ] ; then
-				dirTokens=\${dirTokens}/\$possibleToken
-			else
-				break
-			fi
-		fi
-	done
-	echo "Extracting \$archiveFile ..."
-	extractDir="\${dirTokens}"
-
-	local errorMessage="
-...Failed while extracting \$archiveFile
-You may need to manually clean up the partially extracted files.
-	"
-	case "\$archiveFile" in
-		*.zip)
-			unzip -q -o -d "\$extractDir" "\$archiveFile" \
-			|| Exit "\$errorMessage"
-			;;
-		*.tgz|*.tar.gz)
-			tar -C "\$extractDir" -xf "\$archiveFile" \
-			|| Exit "\$errorMessage"
-			;;
-		*)
-			echo "Unhandled archive extension in InstallOptionalHaikuImagePackage()"
-			exit 1
-			;;
-	esac
-
-	if [ -f '/boot/.OptionalPackageDescription' ] ; then
-		rm '/boot/.OptionalPackageDescription'
-	fi
-	rm "\$archiveFile"
-}
-
-
-function InstallSourceArchive()
-{
-	if [ \$HAIKU_INCLUDE_SOURCES -gt 0 ]; then
-		echo "InstallSourceArchive is not implemented."
-	fi
-}
-
-
-function AddDirectoryToHaikuImage()
-{
-	# AddDirectoryToHaikuImage directoryTokens : attributeFiles
-	# Wrapper for Jam rule
-	ParseFunctionArguments "\$@"
-
-	local dirTokens="/boot/\${functionArgs[0]}"
-	TrimLeadingSpace dirTokens
-	TrimEndingSpace dirTokens
-	dirTokens=\${dirTokens//' '/\/}
-
-	mkdir -p "\${dirTokens}"
-}
-
-
-function AddSymlinkToHaikuImage()
-{
-	# AddSymlinkToHaikuImage <dir tokens> : <link target> [ : <link name> ]
-	# Wrapper for Jam rule
-	ParseFunctionArguments "\$@"
-
-	local dirTokens="/boot/\${functionArgs[0]}"
-	TrimLeadingSpace dirTokens
-	TrimEndingSpace dirTokens
-	dirTokens=\${dirTokens//' '/\/}
-
-	local linkTarget="\${functionArgs[1]}"
-	TrimLeadingSpace linkTarget
-	TrimEndingSpace linkTarget
-
-	local linkName="\${functionArgs[2]}"
-	TrimLeadingSpace linkName
-	TrimEndingSpace linkName
-
-	mkdir -p "\${dirTokens}"
-
-	if [ "\${linkName}" == '' ] ; then
-		ln -sf "\${linkTarget}" -t "\${dirTokens}"
-	else
-		ln -sf "\${linkTarget}" "\${dirTokens}/\${linkName}"
-	fi
-}
-
-
-function AddUserToHaikuImage()
-{
-	# AddUserToHaikuImage user : uid : gid : home : shell : realName
-	# Wrapper for Jam rule
-	ParseFunctionArguments "\$@"
-
-	local user=\${functionArgs[0]}
-	local uid=\${functionArgs[1]}
-	local gid=\${functionArgs[2]}
-	local home=\${functionArgs[3]}
-	local shell=\${functionArgs[4]}
-	local realName=\${functionArgs[5]}
-
-	passwdLine="\${user}:x:\${uid}:\${gid}:\${realName}:\${home}:\${shell}"
-	passwdLine=\${passwdLine//' :'/':'}
-	passwdLine=\${passwdLine//': '/':'}
-
-	local length=\${#passwdLine}
-	((length--))
-	if [ "\${passwdLine:\$length}" == ' ' ] ; then
-		passwdLine=\${passwdLine%' '}
-	fi
-
-	passwdFile="\`finddir B_COMMON_ETC_DIRECTORY\`/passwd"
-	touch \${passwdFile}
-
-	local userExists=1
-	while read line ; do
-		if [ "\${passwdLine}" == "\${line}" ] ; then
-			userExists=0
-		fi
-	done < \${passwdFile}
-
-	if [ \$userExists -ge 1 ] ; then
-		echo "\${passwdLine}" >> \${passwdFile}
-	fi
-}
-
-
-function AddExpanderRuleToHaikuImage()
-{
-	# AddExpanderRuleToHaikuImage <mimetype> : <extension> : <list> : <extract>
-	# Wrapper for Jam rule
-	ParseFunctionArguments "\$@"
-
-	local mimetype=\${functionArgs[0]}
-	local extension=\${functionArgs[1]}
-	local list=\${functionArgs[2]}
-	local extract=\${functionArgs[3]}
-
-	# clean up the variables
-	TrimLeadingSpace mimetype
-	TrimEndingSpace mimetype
-	TrimLeadingSpace extension
-	TrimEndingSpace extension
-	TrimLeadingSpace list
-	TrimEndingSpace list
-	TrimLeadingSpace extract
-	TrimEndingSpace extract
-	local rule_raw="\${mimetype}\\t\${extension}\\t\${list}\\t\${extract}"
-
-	# reset this at every invocation
-	ruleFound=
-
-	if [ \${expanderRulesFileExists} ] ; then
-		# Check if a rule for the mimetype & extension exists.
-		while read line ; do
-			existing_rule=`echo \$line | awk '{ print \$1\$2 }'`
-			if [ "\${mimetype}\${extension}" == "\${existing_rule}" ] ; then
-				ruleFound=1
-				break
-			fi
-		done < "\${expanderRulesFile}"
-	fi
-	if ! [ \${expanderRulesFileExists} ] || ! [ \${ruleFound} ] ; then
-		# Either expander.rules does not exist or a rule for mimetype &
-		# extension does not exist. Output the new rule directly to it.
-		echo -e \${rule_raw} >> \${expanderRulesFile}
-	fi
-}
-
-
-EOF
-#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-	cat ${tmpDir}/optpkg.stage2 >> ${tmpDir}/install-optpkg.sh
-	rm ${tmpDir}/optpkg.stage2
-}
-
-
-function ContainsSubstring()
-{
-	# ContainsSubstring <stringToLookIn> <stringToLookFor>
-	local string="$1"
-	local substring="$2"
-	local newString=${string/${substring}/''}
-	if [ ${#string} -eq $((${#newString} + ${#substring})) ] ; then
-		return 0
-	fi
-	return 1
-}
-
-
-function ErrorExit()
-{
-	echo $1
-	exit 1
-}
-
-
-function Init()
-{
-
-	# Set up some directory paths
-	baseDir=`finddir B_COMMON_DATA_DIRECTORY`/optional-packages
-	tmpDir=`finddir B_COMMON_TEMP_DIRECTORY`
-	libDir=`finddir B_SYSTEM_LIB_DIRECTORY`
-
-	installedPackagesFile="${baseDir}/InstalledPackages"
-
-	# Make sure these files are empty.
-	echo "" > ${tmpDir}/optpkg.jam
-	echo "" > ${tmpDir}/optpkg.stage1
-
-	if ! [ -d ${baseDir} ] ; then
-		mkdir -p ${baseDir}
-	fi
-
-	DetectSystemConfiguration
-	DownloadAllBuildFiles
-	ReadInstalledPackagesIntoMemory
-	ReadPackageNamesIntoMemory
-}
-
-
-function DownloadAllBuildFiles()
-{
-	# DownloadAllBuildFiles
-	# Retreive the necessary jam files from svn.
-	local buildFiles="BuildFeatures OptionalPackageDependencies \
-		OptionalPackages OptionalLibPackages"
-	for file in ${buildFiles} ; do
-		GetBuildFile ${file}
-	done
-
-}
-
-
-function GetBuildFile()
-{
-	# GetBuildFile <file>
-	# Downloads files from Haiku's svn
-	local buildfile="$1"
-	if ! [ -f ${baseDir}/${buildfile} ] ; then
-		echo "Fetching ${buildfile} ..."
-		cd ${baseDir}
-		local baseURL=http://cgit.haiku-os.org/haiku/plain
-		local revisionTag=`uname -v | awk '{print $1}' | sed -e 's/-.*//'`
-			# the sed invocation above drops potential dirty markers off the
-			# revision tag
-		local url="${baseURL}/build/jam/${buildfile}?id=${revisionTag}"
-		wget -q ${url} -O ${buildfile} \
-			|| ErrorExit "...failed to download $buildfile"
-	fi
-}
-
-
-function DetectSystemConfiguration()
-{
-
-	# Determine which GCC we're running
-	if [ -f "$libDir"/libsupc++.so ] ; then
-		HAIKU_GCC_VERSION[1]=4
-	else
-		HAIKU_GCC_VERSION[1]=2
-	fi
-
-	# Test for hybrid
-	if [ -d "$libDir"/gcc4 -a -d "$libDir"/gcc2 ]; then
-		echo "Sorry, but your build appears to be broken ..."
-		echo "Both gcc2 and gcc4 subdirs exist."
-		exit 1
-	elif [ -d "$libDir"/gcc4 -o -d "$libDir"/gcc2 ]; then
-		isHybridBuild=1
-	else
-		isHybridBuild=""
-	fi
-
-	# Determine the Architecture.
-	if [ `uname -m` == "BePC" ] ; then
-		TARGET_ARCH='x86'
-	elif [ `uname -m` == "x86_64" ] ; then
-		TARGET_ARCH='x86_64'
-	else
-		echo "Sorry, x86 only for now."
-		exit 1
-	fi
-}
-
-
-function ReadInstalledPackagesIntoMemory()
-{
-	while read line ; do
-		alreadyInstalled="${alreadyInstalled} $line"
-		packageIgnoreList=${packageIgnoreList/"${line} "/' '}
-	done < ${installedPackagesFile}
-}
-
-
-function ReadPackageNamesIntoMemory()
-{
-	local file="${baseDir}/OptionalPackageNames"
-	if ! [ -f ${file} ] ; then
-		GeneratePackageNames
-	fi
-
-	# read list into associative array
-	while read line ; do
-		local pkg=`echo ${line} | awk '{print $1}'`
-		local pkgDeps=${line/"${pkg} :"/}
-		availablePackages[${pkg}]="${pkgDeps}"
-		availablePackagesKeys="${availablePackagesKeys} ${pkg}"
-	done < ${file}
-}
-
-
-function GeneratePackageNames()
-{
-	# GeneratePackageNames
-	# Creates a file containing available package names
-	# Each line shows a pakage and all of its recrusive dependencies
-	# "<pkg> : <dep1> <dep2> ..."
-	echo "Generating a list of Package Names ..."
-
-	local file="${baseDir}/OptionalPackageNames"
-	if [ -e "${file}" ]; then
-		rm "${file}"
-	fi
-
-	local regExp='/^if\ \[\ IsOptionalHaikuImagePackageAdded/p'
-	sed -n -e "$regExp" ${baseDir}/OptionalPackages > ${file}.temp
-	sed -n -e "$regExp" ${baseDir}/OptionalLibPackages >> ${file}.temp
-	while read line ; do
-		# in each non-filtered line, the 4th word is the optional package
-		local pkg=`echo ${line} | awk '{print $4}'`
-
-		nonRepeatingDeps=""
-		GetPackageDependencies "$pkg"
-		local lowerCasePkg=`echo ${pkg} | tr '[A-Z]' '[a-z]'`
-		if ! ContainsSubstring "${alreadyInstalled} " "${pkg} " ; then
-			if IsPackageAndDepsOkToInstall ${pkg} ; then
-				echo "${lowerCasePkg} : ${pkg} ${nonRepeatingDeps}" >> ${file}
-			fi
-		fi
-
-	done < ${file}.temp
-	rm ${file}.temp
-}
-
-
-function GetPackageDependencies()
-{
-	# GetPackageDependencies <pkg>
-
-	# parse OptionalPackageDependencies for the single line that defines
-	# this optional package's dependencies.
-	local regExp="^OptionalPackageDependencies\ ${1}\ \:"
-	local inputFile="${baseDir}/OptionalPackageDependencies"
-
-	# print that single line
-	sed -n -e "/${regExp}\ /p" ${inputFile} > ${tmpDir}/optpkg.temp
-
-	# strip out "OptionalPackageDependencies PackageName :"
-	# this leaves "<dep1> .... ;"
-	tempDeps=`sed -e "s/${regExp}\ //" ${tmpDir}/optpkg.temp`
-
-	for foo in ${tempDeps%' ;'} ; do
-		# Prevent duplicate entries of the same dependency package.
-		if ! ContainsSubstring "${nonRepeatingDeps} " "${foo} " ; then
-			nonRepeatingDeps="$foo $nonRepeatingDeps "
-			nonRepeatingDeps="${nonRepeatingDeps//  / }"
-		fi
-	done
-
-	# Recursively get the dependencies of these dependencies.
-	for dep in ${tempDeps%' ;'} ; do
-		GetPackageDependencies "$dep"
-	done
-
-}
-
-
-function IsPackageAndDepsOkToInstall()
-{
-	# IsPackageAndDepsOkToInstall <pkg>
-	if ContainsSubstring "${packageIgnoreList}" "${1}"; then
-		#echo "...warning: ${1} cannot be installed"
-		return 1
-	fi
-	for foo in ${nonRepeatingDeps} ; do
-		if ContainsSubstring "${packageIgnoreList}" "${foo}"; then
-			#echo "...warning: ${1} cannot be installed because of ${foo}"
-			return 1
-		fi
-	done
-	return 0
-}
-
-
-function BuildListOfRequestedPackages()
-{
-	if [ "$1" = '-a' ] || [ "$1" = '-s' ]; then
-		shift
-	fi
-	while [ $# -gt 0 ]; do
-		local lowerCase=`echo $1 | tr '[A-Z]' '[a-z]'`
-		wantsToInstall="${wantsToInstall} $lowerCase"
-		shift
-	done
-}
-
-
-function AddPackages()
-{
-	# AddPackages
-
-	# If one or more packages can be installed, do it.
-	if BuildFinalListOfPackagesToInstall ; then
-
-		for package in ${packagesToInstall} ; do
-			# output the "if [ IsOptionalHaikuImagePackageAdded..." code block
-			local regExp="if\ \[\ IsOptionalHaikuImagePackageAdded\ ${package}\ "
-			for inputFile in OptionalPackages OptionalLibPackages ; do
-				sed -n "/^$regExp/,/^\}/p" "${baseDir}/${inputFile}" >> ${tmpDir}/optpkg.jam
-			done
-		done
-
-		ConvertJamToBash "${tmpDir}/optpkg.jam"
-		rm "${tmpDir}/optpkg.jam"
-		CreateInstallerScript
-		sh ${tmpDir}/install-optpkg.sh
-		exitcode=$?
-		if [ $exitcode -gt 0 ]; then
-			ErrorExit "... something went wrong when installing packages."
-		fi
-		rm ${tmpDir}/install-optpkg.sh
-
-		# update files to account for the newly installed packages
-		alreadyInstalled="${alreadyInstalled} ${packagesToInstall} "
-		RecordInstalledPackages
-		GeneratePackageNames
-		echo "... done."
-	fi
-}
-
-
-function BuildFinalListOfPackagesToInstall()
-{
-	# BuildFinalListOfPackagesToInstall
-
-	packagesToInstall=""
-	proceedWithInstallation=false
-
-	for desiredPackage in ${wantsToInstall}; do
-		if IsPackageNameValid $desiredPackage ; then
-			for item in ${availablePackages[${desiredPackage}]} ; do
-				if ! ContainsSubstring "${packagesToInstall}" "${item}" ; then
-					packagesToInstall="${packagesToInstall} ${item}"
-				fi
-			done
-			proceedWithInstallation=true
-		fi
-	done
-	# pad the variable
-	packagesToInstall="${packagesToInstall} "
-	# remove entries that are already installed
-	for skip in ${alreadyInstalled}; do
-		packagesToInstall=${packagesToInstall/"${skip} "/}
-	done
-	# strip double spaces
-	packagesToInstall=${packagesToInstall/"  "/" "}
-
-	if ! [ ${#packagesToInstall} -gt 1 ]; then
-		echo "... no packages need to be installed."
-		echo ""
-		echo "If you wish to re-install a package, run these two commands"
-		echo "    rm ${baseDir}/OptionalPackageNames"
-		echo "    open $installedPackagesFile"
-		echo "and delete the line containing the package name(s)."
-		echo ""
-		proceedWithInstallation=false
-	fi
-	if ! $proceedWithInstallation ; then
-		echo 'Not proceeding with installation.'
-		return 1
-	fi
-	echo "To be installed: ${packagesToInstall}"
-	return 0
-}
-
-
-function IsPackageNameValid()
-{
-	# IsPackageNameValid <name>
-	for name in ${availablePackagesKeys} ; do
-		if [ "$1" == "$name" ] ; then
-			return 0
-		fi
-	done
-	return 1
-}
-
-
-function RecordInstalledPackages()
-{
-	echo -e ${alreadyInstalled} | tr '\ ' '\n' | sort > ${installedPackagesFile}
-}
-
-
-function ConvertJamToBash()
-{
-	# ConvertJamToBash <input file>
-	# The main Jam-to-Bash conversion function.
-	local inputFile=$1
-	declare -a generatedBash
-	countGenBashLine=0
-
-	# Parse out some variable declarations
-
-	# TODO : add these following variables to the CreateInstallerScript
-	# TODO : parse HAIKU_ICU_GCC_2_PACKAGE
-	#local regExp='/^HAIKU_ICU_GCC_2_PACKAGE/p'
-	#icuGcc2PkgLine=`sed -n -e "$regExp" ${baseDir}/BuildFeatures`
-	#ConvertVariableDeclarationLines "$regExp" 'icuGcc2PkgLine'
-
-	# TODO : parse HAIKU_ICU_GCC_4_PACKAGE
-	#local regExp='/^HAIKU_ICU_GCC_4_PACKAGE/p'
-	#icuGcc4PkgLine=`sed -n -e "$regExp" ${baseDir}/BuildFeatures`
-	#ConvertVariableDeclarationLines "$regExp" 'icuGcc4PkgLine'
-
-	# TODO : parse HAIKU_ICU_DEVEL_PACKAGE
-	#local regExp='/^HAIKU_ICU_DEVEL_PACKAGE/p'
-	#icuDevelPkgLine=`sed -n -e "$regExp" ${baseDir}/BuildFeatures`
-	#ConvertVariableDeclarationLines "$regExp" 'icuDevelPkgLine'
-
-	# TODO : fix the regex
-	local regExp="/^\s*HAIKU_OPENSSL_PACKAGE = .*-gcc${HAIKU_GCC_VERSION[1]}-/p"
-	sslPkgLine=`sed -n -e "$regExp" ${baseDir}/BuildFeatures`
-	ConvertVariableDeclarationLines "$regExp" 'sslPkgLine'
-
-	# TODO : fix the regex
-	local regExp='/^HAIKU_OPENSSL_URL/p'
-	sslUrlLine=`sed -n -e "$regExp" ${baseDir}/BuildFeatures`
-	ConvertVariableDeclarationLines "$regExp" 'sslUrlLine'
-
-	# TODO : fix the regex
-	local regExp='/^HAIKU_WEBKIT_FILE/p'
-	webkitFileLine=`sed -n -e "$regExp" ${baseDir}/BuildFeatures`
-	ConvertVariableDeclarationLines "$regExp" 'webkitFileLine'
-
-	local regExp='/^local\ baseURL/p'
-	urlLine=`sed -n -e "$regExp" ${baseDir}/OptionalPackages`
-	urlLine=${urlLine/local\ /''}
-	ConvertVariableDeclarationLines "$regExp" 'urlLine'
-
-	# Convert the easy bits.
-	while read line ; do
-		line=${line/'Echo'/'echo'}
-
-		# TODO: add support for converting for loops.
-		#		will need to introduce curly brace counting
-		ConvertIfStatements "$line"
-		ConvertVariables "$line"
-		#ReplaceComparators "$line"
-
-		line=${line/"IsOptionalHaikuImagePackageAdded"/'"SomeText" !='}
-		generatedBash[$countGenBashLine]=${line}
-		((countGenBashLine++))
-	done < ${tmpDir}/optpkg.jam
-
-	# output stage 1 generated code
-	local i=0
-	while [ $i -lt $countGenBashLine ] ; do
-		echo ${generatedBash[$i]} >> ${tmpDir}/optpkg.stage1
-		((i++))
-	done
-
-	# This converts multi-line jam statements into a single line.
-	# --- Start awk ---
-	awk '
-		/InstallOptionalHaikuImagePackage/,/\;/{
-			isRule=1;
-			if($0~/\;/) ORS="\n";
-			else ORS=" "; print
-		}
-		/AddSymlinkToHaikuImage/,/\;/{
-			isRule=1;
-			if($0~/\;/) ORS="\n";
-			else ORS=" "; print
-		}
-		/AddUserToHaikuImage/,/\;/{
-			isRule=1;
-			if($0~/\;/) ORS="\n";
-			else ORS=" "; print
-		}
-		/AddExpanderRuleToHaikuImage/,/\;/{
-			isRule=1;
-			if($0~/\;/) ORS="\n";
-			else ORS=" "; print
-		}
-		/Exit/,/\;/{
-			isRule=1;
-			if($0~/\;/) ORS="\n";
-			else ORS=" "; print
-		}
-		{
-			if($1!='InstallOptionalHaikuImagePackage' && isRule!=1 && $1!="\;")
-			print $0
-		}
-		{ isRule=0; }
-		' ${tmpDir}/optpkg.stage1 > ${tmpDir}/optpkg.stage2 2>/dev/null
-	# --- End awk ---
-	rm ${tmpDir}/optpkg.stage1
-}
-
-
-function ConvertVariableDeclarationLines()
-{
-	# ConvertVariableDeclarationLines <regex> <variable>
-	# One of the Jam-to-Bash conversion functions.
-	# Jam lines that define variables need to be parsed differently.
-	eval local input='$'"$2"
-	local regex="$1"
-	local _outvar="$2"
-
-	input=${input/\ =\ /=}
-	input=${input/\;/''}
-	input=${input//\(/'{'}
-	input=${input//\)/'}'}
-
-	eval $_outvar="'$input'"
-}
-
-
-function ConvertIfStatements()
-{
-	# ConvertIfStatements <line>
-	# One of the Jam-to-Bash conversion functions.
-	line=${line//'} else {'/'else '}
-	line=${line//'} else if '/'elif '}
-	if ContainsSubstring "$line" "if " ; then
-		if ! ContainsSubstring "$line" "if [" ; then
-			line=${line/'if '/'if [ '}
-		fi
-
-		if ContainsSubstring "$line" '] {' ; then
-			line=${line/'{'/' ; then'}
-		elif ContainsSubstring "$line" '{' ; then
-			line=${line/'{'/' ] ; then'}
-		fi
-
-		for compound in '&&' '||' ; do
-			if ContainsSubstring "$line" "$compound" ; then
-				line=${line/"$compound"/"] $compound ["}
-			fi
-		done
-		ReplaceComparators "$line"
-	fi
-	# Assume all remaining closing braces are part of if statements
-	line=${line/'}'/'fi'}
-}
-
-
-function ConvertVariables()
-{
-	# ConvertVariables
-	# One of the Jam-to-Bash conversion functions.
-
-	# NOTE: jam's variables are normally '$(VARIABLE)'. \n
-	#		The issue is with '(' and ')', so let's replace them globally.
-	if ContainsSubstring "$line" '$(' ; then
-		line=${line//'('/'{'}
-		line=${line//')'/'}'}
-	fi
-}
-
-
-function ReplaceComparators()
-{
-	# ReplaceComparators <line>
-	# One of the Jam-to-Bash conversion functions.
-
-	# Preserve string comparators for TARGET_ARCH.
-	if ! ContainsSubstring "$line" 'TARGET_ARCH' ; then
-		line=${line//'>='/'-ge'}
-		line=${line//'<='/'-le'}
-		line=${line//'>'/'-gt'}
-		line=${line//'<'/'-lt'}
-		line=${line//'!='/'-ne'}
-		line=${line//'='/'-eq'}
-	fi
-}
-
-
-function DisplayUsage()
-{
-	echo -e "$DISCLAIMER"
-	echo -e "$USAGE"
-}
-
-
-function RemoveCachedFiles()
-{
-	# RemoveCachedFiles
-	echo "Removing cached files ..."
-	if [ -e ${baseDir}/OptionalPackageNames ]; then
-		rm ${baseDir}/OptionalPackageNames
-	fi
-
-	# Unset variables, which prevents duplicate entries.
-	declare -A availablePackages
-	declare availablePackagesKeys=""
-
-	# Reinitialize
-	Init
-}
-
-
-function ListPackages()
-{
-	# ListPackages
-	echo ""
-	echo "Optional Packages that have been installed:"
-	echo ${alreadyInstalled}
-
-	echo ""
-	echo ""
-	echo "Installable Optional Packages:"
-
-	# single line:
-	echo ${availablePackagesKeys}
-
-	# one per line:
-	#for package in ${availablePackagesKeys} ; do
-	#	echo ${package}
-	#done
-}
-
-
-# If no arguments were passed to the script, display its usage and exit.
-if [ "$#" -lt 1 ] ; then
-	DisplayUsage
-	exit 0
-else
-	Init
-fi
-
-# Support `installoptionalpackage <pkg> <pkg> ...`
-if [ "$1" != '-f' ] && [ "$1" != '-l' ] && [ "$1" != '-h' ] \
-	&& [ "$1" != '-s' ]; then
-	BuildListOfRequestedPackages $@
-	AddPackages
-	exit 0
-fi
-
-# Parse the arguments given to the script.
-while getopts "as:fhl" opt; do
-	case $opt in
-		a)
-			BuildListOfRequestedPackages $@
-			AddPackages
-			exit 0
-			;;
-		f)
-			RemoveCachedFiles
-			ListPackages
-			exit 0
-			;;
-		h)
-			DisplayUsage
-			exit 0
-			;;
-		l)
-			ListPackages
-			exit 0
-			;;
-		s)
-			BuildListOfRequestedPackages $@
-			BuildFinalListOfPackagesToInstall
-			exit 0
-			;;
-		\?)
-			echo "Invalid option: -$OPTARG" >&2
-			exit 1
-			;;
-		:)
-			echo "Option -$OPTARG requires an argument." >&2
-			exit 1
-			;;
-	esac
-done

data/bin/setgcc

@@ -1,99 +0,0 @@
-#!/bin/sh
-#
-# setgcc [ <arch> ] [ <gcc> ]
-
-abiDir=/boot/develop/abi
-abiLink=$abiDir/current
-libDir=/boot/develop/lib
-
-usage()
-{
-	cat << EOF
-Usage: $0 [ <arch> ] [ <gcc> ]
-
-Sets the current gcc version, respectively prints it, if no arguments are
-given.
-
-  <arch>  - The architecture to set. Supported values: "x86", "ppc".
-  <gcc>   - The major gcc version to set. Supported values: "gcc2", "gcc4".
-
-EOF
-}
-
-if [ $# -gt 2 ]; then
-	usage
-	exit 1
-fi
-
-if [ $# -eq 0 ]; then
-	if [ -h $abiLink ]; then
-		abi=$(readlink $abiLink 2> /dev/null) || {
-			echo "Failed to read GCC symlink." >&2
-			exit 1
-		}
-		echo "Current GCC: $abi"
-		exit
-	else
-		echo "GCC symlink not installed." >&2
-		exit 1
-	fi
-fi
-
-arch=
-gcc=
-
-# parse the args
-while [ $# -gt 0 ]; do
-	case $1 in
-		-h,--help)	usage; exit;;
-		x86)		arch=$1;;
-		ppc)		arch=$1;;
-		gcc2|gcc4)	gcc=$1;;
-		*)			usage; exit 1;;
-	esac
-
-	shift
-done
-
-# use the native arch, if not given
-if [ -z "$arch" ]; then
-	case $(uname -m) in
-		BePC)	arch=x86;;
-		*)		echo "Can't guess native architecture. Please specify!" >&2
-				exit 1;;
-	esac
-fi
-
-# guess the native gcc version, if not given
-if [ -z "$gcc" ]; then
-	if [ -e /system/lib/gcc2 ]; then
-		gcc=gcc4
-	elif [ -e /system/lib/gcc4 ]; then
-		gcc=gcc2
-	elif [ -e /system/lib/libstdc++.r4.so ]; then
-		gcc=gcc2
-	else
-		echo "Can't guess native GCC version. Please specify!" >&2
-		exit 1
-	fi
-fi
-
-# check whether the gcc exists
-count=`ls -l $abiDir/$arch/$gcc/tools/current/bin/*gcc 2>/dev/null | wc -l`
-if [ $count -eq 0 ]; then
-	echo "Can't set GCC $arch/$gcc -- not installed." >&2
-	exit 1
-fi
-
-# create the symlink
-( rm $abiLink && ln -sf $arch/$gcc $abiLink ) || {
-	echo "Failed to set GCC $arch/$gcc." >&2
-	exit 1
-}
-
-# create the lib symlink
-libLink=$libDir/$arch
-( rm -f $libLink && ln -sf $abiDir/$arch/$gcc/lib $libLink ) || {
-	echo "Failed to set lib $arch/$gcc." >&2
-	exit 1
-}

data/common/boot/post_install/add_catalog_entry_attributes.sh

@@ -33,6 +33,7 @@ WriteMailCatalogEntryAttribute()
 }
 
 
+# TODO: Several of the directories are read-only, so this doesn't work.
 WriteTrackerCatalogEntryAttribute \
 	"$(finddir B_APPS_DIRECTORY)" B_APPS_DIRECTORY
 
@@ -55,8 +56,6 @@ WriteTrackerCatalogEntryAttribute \
 	"$(finddir B_USER_SETTINGS_DIRECTORY)/Tracker/Tracker New Templates" \
 	"B_USER_SETTINGS_DIRECTORY/Tracker/Tracker New Templates"
 
-WriteTrackerCatalogEntryAttribute "/boot/optional" "/boot/optional"
-
 WriteTrackerCatalogEntryAttribute \
 	"$(finddir B_PREFERENCES_DIRECTORY)" B_PREFERENCES_DIRECTORY
 

data/common/boot/post_install/mime_update.sh

@@ -1,44 +0,0 @@
-#!/bin/sh
-
-_progress () {
-	notify --type progress --group "MIME type updater" \
-	--timeout ${3:-30} \
-	--icon /boot/system/apps/DiskProbe \
-	--messageID $0_$$ \
-	--title "Updating file MIME types..." \
-	--progress $1 "$2" >/dev/null
-}
-
-_progress 0.0 "desktop files"
-
-# Make sure files on the desktop are mimeset first
-
-for f in $(/bin/finddir B_DESKTOP_DIRECTORY 2>/dev/null\
-	|| echo "/boot/home/Desktop")/*; do
-	if [ -f "$f" ]; then
-		mimeset -f "$f"
-	fi
-done
-
-# Make sure all apps have a MIME DB entry.
-
-SYSTEM=$(/bin/finddir B_SYSTEM_DIRECTORY 2>/dev/null || echo "/boot/system")
-
-mimeset -f "$SYSTEM/bin/userguide"
-mimeset -f "$SYSTEM/bin/welcome"
-
-_progress 0.1 "system applications"
-mimeset -apps -f "$SYSTEM/apps"
-_progress 0.2 "documentation"
-mimeset       -f "$SYSTEM/documentation"
-_progress 0.3 "preferences"
-mimeset -apps -f "$SYSTEM/preferences"
-_progress 0.4 "servers"
-mimeset -apps -f "$SYSTEM/servers"
-_progress 0.5 "applications"
-mimeset -apps -f "/boot/apps"
-_progress 0.7 "application (by signature)"
-
-query -f 'BEOS:APP_SIG=*' | xargs --no-run-if-empty mimeset -apps -f
-
-_progress 1.0 "done" 10

data/config/boot/UserBootscript

@@ -3,7 +3,7 @@
 # DO NOT EDIT!
 #=====================================================================
 # Start programs and open files in the boot launch folder
-for file in $HOME/config/boot/launch/* 
+for file in $HOME/config/settings/boot/launch/* 
 do 
 	/bin/open "$file" &
 done

data/system/boot/Bootscript

@@ -104,6 +104,8 @@ fi
 
 launch $SERVERS/debug_server				# launch debug_server
 
+launch $SERVERS/package_daemon
+
 # Init Network
 if [ "$SAFEMODE" != "yes" ]; then
 	launch $SERVERS/net_server				# launch net_server
@@ -184,20 +186,21 @@ launch system/preferences/Time "" --update
 
 if [ "$SAFEMODE" != "yes" ]; then
 	# Start user boot script
-	if [ -f $HOME/config/boot/UserBootscript ]; then
+	if [ -f $HOME/config/settings/boot/UserBootscript ]; then
-		. $HOME/config/boot/UserBootscript
+		. $HOME/config/settings/boot/UserBootscript
 	fi
 fi
 
 # Check for fresh install and run post install scripts.
 freshInstallIndicator=/boot/common/settings/fresh_install
-postInstallDir=/boot/common/boot/post_install
+postInstallDir=boot/post-install
 if [ -e $freshInstallIndicator ]; then
 	# wait a moment for things to calm down a bit
 	sleep 3
 
 	# execute scripts
-	for f in $postInstallDir/*.sh; do
+	for f in /boot/system/$postInstallDir/*.sh /boot/common/$postInstallDir/*.sh
+	do
 		if [ -f $f ]; then
 			echo "Running post install script $f ..." > /dev/dprintf
 			$f

data/system/boot/SetupEnvironment

@@ -6,8 +6,7 @@
 export HOME=/boot/home
 export LC_CTYPE="en_US.UTF-8"
 
-BUILDHOME=/boot/develop
+BUILDHOME=/boot/system/develop
-BETOOLS="$BUILDHOME/tools/gnupro/bin"
 
 case `uname -m` in
 BePC|Intel|unknown)
@@ -20,33 +19,23 @@ BeMac|BeBox)
 	BE_HOST_CPU=`uname -m`
 esac
 
-BELIBRARIES="$BUILDHOME/abi/current/library-paths/common:$BUILDHOME/lib/$BE_HOST_CPU"
+# not used by Haiku, but by (legacy) applications (e.g. Pe)
 BH=$BUILDHOME/headers
 BEINCLUDES="$BH;$BH/be;$BH/posix;$BH/glibc;$BH/cpp;$BH/be/app;$BH/be/device;$BH/be/interface;$BH/be/locale;$BH/be/media;$BH/be/midi;$BH/be/midi2;$BH/be/net;$BH/be/kernel;$BH/be/storage;$BH/be/support;$BH/be/game;$BH/be/opengl;$BH/be/drivers;$BH/gnu;$BH/be/mail;$BH/be/translation;$BH/be/devel;$BH/be/add-ons/graphics;$BH/be/be_apps/Deskbar;$BH/be/be_apps/NetPositive;$BH/be/be_apps/Tracker"
 
 export BUILDHOME
-export BETOOLS
-export BELIBRARIES
 export BEINCLUDES
 export BE_HOST_CPU
 
-# for the "cc" and "ld" shell scripts
-
-export BE_C_COMPILER=gcc
-export BE_CPLUS_COMPILER="g++"
-export BE_LINKER=ld
-export BE_DEFAULT_C_FLAGS=""
-export BE_DEFAULT_CPLUS_FLAGS=""
-
 if [ "$SAFEMODE" != "yes" ]
 then
-	export PATH=.:$HOME/config/bin:/boot/common/bin:/bin:/boot/apps:/boot/preferences:/boot/system/apps:/boot/system/preferences:$BETOOLS
+	export PATH=.:$HOME/config/non-packaged/bin:$HOME/config/bin:/boot/common/non-packaged/bin:/boot/common/bin:/bin:/boot/common/apps:/boot/common/preferences:/boot/system/apps:/boot/system/preferences
-	export LIBRARY_PATH="%A/lib:$HOME/config/lib:/boot/common/lib:/boot/system/lib"
+	export LIBRARY_PATH="%A/lib:$HOME/config/non-packaged/lib:$HOME/config/lib:/boot/common/non-packaged/lib:/boot/common/lib:/boot/system/lib"
-	export ADDON_PATH="%A/add-ons:$HOME/config/add-ons:/boot/common/add-ons:/boot/system/add-ons"
+	export ADDON_PATH="%A/add-ons:$HOME/config/non-packaged/add-ons:$HOME/config/add-ons:/boot/common/non-packaged/add-ons:/boot/common/add-ons:/boot/system/add-ons"
 else
-	export PATH=.:/boot/common/bin:/bin:/boot/apps:/boot/preferences:/boot/system/apps:/boot/system/preferences:$BETOOLS
+	export PATH=.:/bin:/boot/common/apps:/boot/system/apps:/boot/system/preferences
-	export LIBRARY_PATH="%A/lib:/boot/common/lib:/boot/system/lib"
+	export LIBRARY_PATH="%A/lib:/boot/system/lib"
-	export ADDON_PATH="%A/add-ons:/boot/common/add-ons:/boot/system/add-ons"
+	export ADDON_PATH="%A/add-ons:/boot/system/add-ons"
 fi
 
 # Locale
@@ -65,8 +54,8 @@ fi
 
 if [ "$SAFEMODE" != "yes" ]
 then
-	if [ -f $HOME/config/boot/UserSetupEnvironment ]
+	if [ -f $HOME/config/settings/boot/UserSetupEnvironment ]
 	then
-     	. $HOME/config/boot/UserSetupEnvironment
+     	. $HOME/config/settings/boot/UserSetupEnvironment
 	fi
 fi

headers/build/host/haiku_host/Errors.h

@@ -0,0 +1 @@
+#include "/boot/system/develop/headers/os/support/Errors.h"

headers/build/host/haiku_host/config_build/HaikuConfig.h

@@ -0,0 +1 @@
+#include "/boot/system/develop/headers/config/HaikuConfig.h"

headers/build/host/haiku_host/config_build/types.h

@@ -0,0 +1 @@
+#include "/boot/system/develop/headers/config/types.h"

headers/build/os/app/Message.h

@@ -22,6 +22,7 @@ class BBlockCache;
 class BMessenger;
 class BHandler;
 class BString;
+class BStringList;
 struct entry_ref;
 
 
@@ -105,6 +106,7 @@ class BMessage {
 		status_t		AddPoint(const char *name, BPoint aPoint);
 		status_t		AddString(const char *name, const char *aString);
 		status_t		AddString(const char *name, const BString &aString);
+		status_t		AddStrings(const char *name, const BStringList &list);
 		status_t		AddInt8(const char *name, int8 value);
 		status_t		AddUInt8(const char *name, uint8 value);
 		status_t		AddInt16(const char *name, int16 value);
@@ -140,6 +142,7 @@ class BMessage {
 		status_t		FindString(const char *name, int32 index, const char **string) const;
 		status_t		FindString(const char *name, BString *string) const;
 		status_t		FindString(const char *name, int32 index, BString *string) const;
+		status_t		FindStrings(const char *name, BStringList *list) const;
 		status_t		FindInt8(const char *name, int8 *value) const;
 		status_t		FindInt8(const char *name, int32 index, int8 *value) const;
 		status_t		FindUInt8(const char *name, uint8 *value) const;

headers/build/os/interface/Gradient.h

@@ -0,0 +1 @@
+#include <../os/interface/Gradient.h>

headers/build/os/interface/IconUtils.h

@@ -0,0 +1 @@
+#include <../os/interface/IconUtils.h>

headers/build/os/package/BlockBufferCacheNoLock.h

@@ -1 +0,0 @@
-#include <../os/package/BlockBufferCacheNoLock.h>

headers/build/os/package/DownloadFileRequest.h

@@ -0,0 +1 @@
+#include <../os/package/DownloadFileRequest.h>

headers/build/os/package/GlobalWritableFileInfo.h

@@ -0,0 +1 @@
+#include <../os/package/GlobalWritableFileInfo.h>

headers/build/os/package/InstallationLocationInfo.h

@@ -0,0 +1 @@
+#include <../os/package/InstallationLocationInfo.h>

headers/build/os/package/User.h

@@ -0,0 +1 @@
+#include <../os/package/User.h>

headers/build/os/package/UserSettingsFileInfo.h

@@ -0,0 +1 @@
+#include <../os/package/UserSettingsFileInfo.h>

headers/build/os/package/WritableFileUpdateType.h

@@ -0,0 +1 @@
+#include <../os/package/WritableFileUpdateType.h>

headers/build/os/package/hpkg/BlockBufferCache.h

@@ -1 +0,0 @@
-#include <../os/package/hpkg/BlockBufferCache.h>

headers/build/os/package/hpkg/BlockBufferPool.h

@@ -0,0 +1 @@
+#include <../os/package/hpkg/BlockBufferPool.h>

headers/build/os/package/hpkg/BlockBufferPoolNoLock.h

@@ -0,0 +1 @@
+#include <../os/package/hpkg/BlockBufferPoolNoLock.h>

headers/build/os/package/hpkg/BufferCache.h

@@ -1 +0,0 @@
-#include <../os/package/hpkg/BufferCache.h>

headers/build/os/package/hpkg/BufferPool.h

@@ -0,0 +1 @@
+#include <../os/package/hpkg/BufferPool.h>

headers/build/os/package/hpkg/NoErrorOutput.h

@@ -0,0 +1 @@
+#include <../os/package/hpkg/NoErrorOutput.h>

headers/build/os/package/hpkg/PackageAttributes.h

@@ -0,0 +1 @@
+#include <../os/package/hpkg/PackageAttributes.h>