Build infrastructure change...

* Renamed build-info to build-query.  The build-query tool is now
  responsible for looking up pretty much any and all package
  information, and all of the tools should use it instead of making
  assumptions about paths.

* Redesigned the package structure to support <category>/<package>.
  When a request is made that excludes the <category> then the
  <project_name> is assumed to be the category.

* Currently anything in the buildtools/ category is not cleaned up
  during build-clean.  In the future there will be a NOCLEAN option as a
  category rule that the Buildrules file implicitly inherits.

11 files changed, 447 insertions, 255 deletions

diff --git a/.gitignore b/.gitignore
index a1eb9c6..a33645a 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,6 +1,6 @@
 root
 artifacts
-packages/*/build
-packages/*/log
-packages/*/install
-packages/*/source
+packages/*/*/build
+packages/*/*/log
+packages/*/*/install
+packages/*/*/source
diff --git a/scripts/build b/scripts/build
index d7fc40d..d81dc41 100755
--- a/scripts/build
+++ b/scripts/build
@@ -1,4 +1,5 @@
 #!/bin/sh
+set -e
 
 ## usage
 # Simply display the builder usage.  Though it would be nice if some of this
@@ -6,14 +7,14 @@
 usage()
 {
 cat<<EOF
-usage: ${0##*/} [options] <command> [command-opts] <package|all>
+usage: ${0##*/} [options] <command> [command-opts] [all|<package> ...]
 
 Options
 -------
  -t, --target	Specify a build-target.  This is a generic concept which tells
 		builder the name of the config rule to pick up from the
 		.builder/ path at the top of the build-tree.  The global config
-		.builder/config is always evaluated before evaluating any
+		.builder/default is always evaluated before evaluating any
 		target-specific configs.  This allows for nightly and release
 		targets, as well as architecture specific variations.
 
@@ -27,7 +28,7 @@ Options
 Commands
 --------
 
-  info		The info is used both internally by builder, as well as allows
+  query		The query is used internally by builder, while allowing
 		one to query various packages from the builder repository.
 
 		options
@@ -51,8 +52,8 @@ Commands
 		and usable within the build rules script. The predefined
 		behavior for this action is to cd into the workdir, produce a
 		configure script from the configure.in if necessary, run the
-		configure with predefined BUILDER_CONFIG_OPTS, and then perform
-		a make with BUILDER_MAKE_OPTS.
+		configure with predefined CONFIG_OPTS, and then perform
+		a make with MAKE_OPTS.
 
   archive	Perform a 'make install' of the package into the package's
 		sysroot and then produce an archive of the package and store
@@ -91,49 +92,22 @@ die()
 # import a package into the current program space
 import()
 {
-	[ -d "${BUILDER_PKGDIR}/${1}" ] || die "no such package '${1}'"
-	[ -f "${BUILDER_PKGDIR}/${1}/Buildrules" ] || die "no rule to build package '${1}'"
-
-	# Set the name so it can be used in the Buildrules
-	NAME="${1}"
-
-	# Clear all the pkg variables that we depend on
-	VERSION=
-	DESCRIPTION=
-	SOURCE_URI=
-	PATCHES=
-	BDEPENDS=
-	RDEPENDS=
+	eval $(build query -E '${1}')
 
-	. "${BUILDER_PKGDIR}/${NAME}/Buildrules"
+	. "${RULESFILE}"
 
 	[ "${NAME}" = "${1}" ] || die "Buildrules can not set the package name"
 	[ -z "${VERSION}" ] && die "missing version in '${NAME}'"
 	[ -z "${DESCRIPTION}" ] && die "missing description in '${NAME}'"
 
-	if [ ! -d "${BUILDER_PKGDIR}/${NAME}/source" ]; then
-		if [ -z "${SOURCE_URI}" ]; then
-			die "SOURCE_URI undefined and no source directory in '${NAME}'"
-		fi
+	if [ -z "${SOURCE_URI}" ]; then
+		die "SOURCE_URI undefined and no source directory in '${PKG_NAME}'"
 	fi
-
-	D="${BUILDER_PKGDIR}/${NAME}/install"
-	W="${BUILDER_PKGDIR}/${NAME}/build"
-	S="${BUILDER_PKGDIR}/${NAME}/build/${NAME}-${VERSION}"
-	F="${BUILDER_PKGDIR}/${NAME}/files"
-	L="${BUILDER_PKGDIR}/${NAME}/log"
 }
 
-set -e
-
-##
-# Argument parsing
-if [ "$#" -eq "0" ]; then
-	set -- "all"
-fi
-
 ##
 # Check to see if we are wrapping a sub-command
+# FIXME support custom commands
 BUILD_COMMAND=
 if [ -f "${1}" ]; then
 	case "${1}" in
@@ -156,7 +130,6 @@ for arg in "$@"; do
 done
 unset arg
 
-TARGET="default"
 DEBUG="0"
 while [ "$#" -gt "0" ]; do
 	case "$1" in
@@ -167,7 +140,7 @@ while [ "$#" -gt "0" ]; do
 			echo "error: no target specified" >&2
 			exit 1
 		fi
-		TARGET="${1}"
+		BUILDER_TARGET="${1}"
 		shift 1
 		;;
 	(-d|-debug|--debug)
@@ -201,61 +174,67 @@ fi
 # This may be a little bit confusing to most.  The core issue here is the
 # ability to deal with compiled-in defaults, user-defined defaults, environment
 # settings, and target settings.
-BUILDER_CFGDIR="${BUILDER_TOPDIR}/.builder"
-
-# first clear the variables that would be set by the configs
-CFGDIR=
-PKGDIR=
-SRCDIR=
-ATFDIR=
-LIBDIR=
+CFGDIR="${BUILDER_TOPDIR}/.builder"
+
 # grab the default and target settings if available, let the target settings
 # override the user-defined defaults.
-if [ "${TARGET}" = "default" ]; then
-	. "${BUILDER_CFGDIR}/default"
+TARGET="default"
+if [ -f "${CFGDIR}/${TARGET}" ]; then
+	. "${CFGDIR}/${TARGET}"
 fi
-
+CFGDIR="${BUILDER_TOPDIR}/.builder"
+TARGET="${BUILDER_TARGET:-${TARGET}}"
 if [ "${TARGET}" != "default" ]; then
-	if [ ! -f "${BUILDER_CFGDIR}/${TARGET}" ]; then
+	if [ ! -f "${CFGDIR}/${TARGET}" ]; then
 		echo "error: invalid target '${TARGET}'" >&2
 		exit 1
 	fi
-	BUILDER_CONFIG="${BUILDER_CFGDIR}/${TARGET}"
+	. "${CFGDIR}/${TARGET}"
+fi
+export TARGET
+
+# Available to be set in the target
+PROJECT_NAME="${PROJECT_NAME:-platform}"
+ARCHIVE_FORMAT="${ARCHIVE_FORMAT:-tar.bz2}"
+export PROJECT_NAME ARCHIVE_FORMAT
+
+# FIXME this stuff needs to be detected in a more reliable fashion
+ARCH="${ARCH:-$(uname -m)}"
+VENDOR="${VENDOR:-pc}"
+PLATFORM="${PLATFORM:-$(uname -i|tr '[A-Z]' '[a-z]')}"
+LIBC="${LIBC:-gnu}"
+export ARCH VENDOR PLATFORM LIBC
+
+# FIXME We should be defaulting to the build platform for this data if the
+# target platform is unspecified
+CHOST="${ARCH}-${VENDOR}-${PLATFORM}-${LIBC}"
+export CHOST
+
+# If the MAKE_OPTS are not set then find the number of CPU's and set them.
+if [ -z "${MAKE_OPTS}" ]; then
+	NUM_CPUS="$(awk '/^processor/{print$3}'< /proc/cpuinfo|sort|uniq|tail -n 1)"
+	NUM_CPUS="$((${NUM_CPUS} + 1))"
+	MAKE_OPTS="-j$((${NUM_CPUS} + 1))"
 fi
-. "${BUILDER_CONFIG}"
+export MAKE_OPTS
 
 # set the builtin defaults based on the BUILDER_TOPDIR
-BUILDER_PKGDIR="${BUILDER_PKGDIR:-${BUILDER_TOPDIR}/packages}"
-BUILDER_SRCDIR="${BUILDER_SRCDIR:-${BUILDER_TOPDIR}/sources}"
-BUILDER_ATFDIR="${BUILDER_ATFDIR:-${BUILDER_TOPDIR}/artifacts}"
-BUILDER_LIBDIR="${BUILDER_LIBDIR:-${BUILDER_TOPDIR}/scripts/builder}"
-BUILDER_SYSROOT="${BUILDER_SYSROOT:-${BUILDER_TOPDIR}/root}"
-
-# set the builder variables based on what was available, either defaults or
-# user-defined, this also allows the BUILDER_* defaults to be overridden by the
-# environ, possibly from within ${HOME}/.profile
-BUILDER_CFGDIR="${CFGDIR:-${BUILDER_CFGDIR}}"
-BUILDER_PKGDIR="${PKGDIR:-${BUILDER_PKGDIR}}"
-BUILDER_SRCDIR="${SRCDIR:-${BUILDER_SRCDIR}}"
-BUILDER_ATFDIR="${ATFDIR:-${BUILDER_ATFDIR}}"
-BUILDER_LIBDIR="${LIBDIR:-${BUILDER_LIBDIR}}"
-BUILDER_SYSROOT="${SYSROOT:-${BUILDER_SYSROOT}}"
-export BUILDER_CFGDIR BUILDER_PKGDIR BUILDER_SRCDIR BUILDER_ATFDIR
-export BUILDER_LIBDIR BUILDER_TOPDIR BUILDER_SYSROOT
+BUILDER_PKGDIR="${BUILDER_TOPDIR}/packages"
+BUILDER_SRCDIR="${BUILDER_TOPDIR}/sources"
+BUILDER_ATFDIR="${BUILDER_TOPDIR}/artifacts"
+BUILDER_LIBDIR="${BUILDER_TOPDIR}/scripts/builder"
 
-ARCHIVE_FORMAT="${ARCHIVE_FORMAT:-tar.bz2}"
-export ARCHIVE_FORMAT
+export BUILDER_CFGDIR BUILDER_PKGDIR BUILDER_SRCDIR
+export BUILDER_ATFDIR BUILDER_LIBDIR BUILDER_TOPDIR
+
+# Installation locations for the cross-tools and the target-root
+TOOLDIR="${TOOLDIR:-${BUILDER_TOPDIR}/toolchain}"
+SYSROOT="${SYSROOT:-${BUILDER_TOPDIR}/sysroot}"
+export TOOLDIR SYSROOT
 
 PATH="${BUILDER_LIBDIR}:${PATH}"
 export PATH
 
-# Do some basic checking regarding the target package
-if [ "$#" -eq "0" ]; then
-	error "no package specified"
-	echo "try '${0} --help'" >&2
-	exit 1
-fi
-
 # if we aren't given an action then we do everything
 ACTION="archive"
 if [ "$#" -gt "0" ]; then
@@ -263,21 +242,29 @@ if [ "$#" -gt "0" ]; then
 	shift 1
 fi
 
-if [ "${ACTION}" = "all" ]; then
-	ACTION="install"
-fi
-
+# FIXME Support custom commands somehow..
 if [ ! -x "${BUILDER_LIBDIR}/build-${ACTION}" ]; then
 	error "unknown action '${ACTION}'"
 	echo "try '${0} --help'" >&2
 	exit 1
 fi
 
+# info is a special case
+# FIXME this is semi-busted
+if [ "${ACTION}" = "query" ]; then
+	exec "${BUILDER_LIBDIR}/build-query" "${@}"
+fi
+
 if [ "$#" -lt "1" ]; then
 	NAME="all"
 	if [ "${PWD##${BUILDER_PKGDIR}/}" != "${PWD}" ]; then
-		NAME="${PWD##${BUILDER_PKGDIR}/}"
-		NAME="${NAME%/*}"
+		name1="${PWD##${BUILDER_PKGDIR}/}"
+		if [ "${name1}" = "${name#*/*/}" ]; then
+			NAME="${name1}"
+		else
+			name2="${name1#*/*/}"
+			NAME="${name1%/${name2}}"
+		fi
 	fi
 	set -- "${NAME}"
 fi
@@ -291,18 +278,10 @@ if [ "${1}" != "all" ]; then
 		if [ "${package}" = "all" ]; then
 			exec "${0}" "${ACTION}" "${package}"
 		fi
-		[ -d "${BUILDER_PKGDIR}/${package}" ] || die "no such package '${package}'"
-		[ -f "${BUILDER_PKGDIR}/${package}/Buildrules" ] || die "no rule to build package '${package}'"
-	done
-fi
-
-# info is a special case
-# FIXME this is semi-busted
-if [ "${ACTION}" = "info" ]; then
-	for package in "$@"; do
-		"${BUILDER_LIBDIR}/build-info" "${package}" "${@}"
+		if ! build-query --exists "${package}"; then
+			exit 1
+		fi
 	done
-	exit
 fi
 
 # build the Makefile
@@ -314,14 +293,9 @@ fi
 export BUILDER_MAKEFILE
 "${BUILDER_LIBDIR}/build-makedeps" || die "failed generate build dependencies"
 
-# FIXME not the right way to handle this, we should be only setting this if the
-# target leaves it empty, and we should stick with the norm of setting it to
-# num_cpus+1
-MAKE_OPTS="-j8"
-export MAKE_OPTS
-
 packages=
 for package in "$@"; do
+	package="$(echo "${package}"|tr '/-' '__')"
 	packages="${packages} ${package}_${ACTION}"
 done
 set -- ${packages}
diff --git a/scripts/builder/build-archive b/scripts/builder/build-archive
index 71690ec..53439d7 100755
--- a/scripts/builder/build-archive
+++ b/scripts/builder/build-archive
@@ -1,7 +1,7 @@
 #!/usr/bin/env build
 
 echo "archiving: ${1}"
-import "${1}"
+eval $(build query --environ "${1}")
 
 ARCHIVE_TMP1=
 ARCHIVE_TMP2=
@@ -37,6 +37,6 @@ if [ -f "${BUILDER_ATFDIR}/${NAME}-${VERSION}.${ARCHIVE_FORMAT}" ]; then
 	rm -f "${BUILDER_ATFDIR}/${NAME}-${VERSION}.${ARCHIVE_FORMAT}"
 fi
 mv -v "${ARCHIVE_TMP2}" "${BUILDER_ATFDIR}/${NAME}-${VERSION}.${ARCHIVE_FORMAT}" >> "${L}/archive.log" 2>&1
-touch -r "${L}/.compiled" "${BUILDER_ATFDIR}/${NAME}-${VERSION}.${ARCHIVE_FORMAT}"
+touch -r "${W}/.compiled" "${BUILDER_ATFDIR}/${NAME}-${VERSION}.${ARCHIVE_FORMAT}"
 
 # vim: filetype=sh
diff --git a/scripts/builder/build-clean b/scripts/builder/build-clean
index dcc8811..6860061 100755
--- a/scripts/builder/build-clean
+++ b/scripts/builder/build-clean
@@ -1,14 +1,15 @@
 #!/usr/bin/env build
 
 echo "cleaning: ${1}"
-import "${1}"
 
-if [ ! -z "${TOOLCHAIN}" ]; then
-	rm -f "${L}/.installed"
-	exit 0
-fi
+case "${PKG_NAME}" in
+# FIXME need a way to flag a path as NOCLEAN
+(buildtools/*)	rm -f "$(build query --workdir "${1}")/.installed"; exit 0;;
+esac
+eval $(build query --environ "${1}")
 
-for dir in "${L}" "${W}" "${D}"; do
+
+for dir in "$(build query --workdir "${1}")" "$(build query --destdir "${1}")"; do
 	if [ -d "${dir}" ]; then
 		rm -rf "${dir}" &
 	fi
diff --git a/scripts/builder/build-compile b/scripts/builder/build-compile
index 0ecad21..2d75b29 100755
--- a/scripts/builder/build-compile
+++ b/scripts/builder/build-compile
@@ -2,19 +2,16 @@
 
 echo "compiling: ${1}"
 
+# FIXME this likely belongs in a imported build rule
 if [ -z "${CHOST}" ]; then
 	CROSS_COMPILE="${CHOST}-"
 	export CROSS_COMPILE CHOST
 fi
 
-if [ -z "${ARCH}" ]; then
-	export ARCH
-fi
-
 # Don't pass along the builder jobcontrol data to child processes
 unset MAKEFLAGS
 
-PATH="${BUILDER_SYSROOT}/usr/bin:${PATH}"
+PATH="${TOOLDIR}/usr/bin:${PATH}"
 export PATH
 
 pkg_compile()
@@ -32,7 +29,8 @@ pkg_compile()
 	make ${MAKE_OPTS} && make DESTDIR="${D}" install
 }
 
-import "${1}"
+eval $(build query --environ "${1}")
+. "${RULESFILE}"
 
 # define the toolchain
 if [ -z "${TOOLCHAIN}" ]; then
@@ -46,9 +44,9 @@ if [ -z "${TOOLCHAIN}" ]; then
 fi
 
 # pkgconfig can be a right pita...
-PKG_CONFIG_LIBDIR="${BUILDER_SYSROOT}/usr/share/pkgconfig:${BUILDER_SYSROOT}/usr/lib/pkgconfig"
+PKG_CONFIG_LIBDIR="${SYSROOT}/usr/share/pkgconfig:${SYSROOT}/usr/lib/pkgconfig"
 export PKG_CONFIG_LIBDIR PKG_CONFIG_PATH
-export PKG_CONFIG_SYSROOT_DIR="${BUILDER_SYSROOT}"
+export PKG_CONFIG_SYSROOT_DIR="${SYSROOT}"
 
 [ -d "${D}" ] || mkdir -p "${D}"
 [ -d "${S}" ] || mkdir -p "${S}"
@@ -62,6 +60,6 @@ echo "=========" >> "${L}/compile.log"
 
 cd "${S}"
 pkg_compile >> "${L}/compile.log" 2>&1
-date --utc > "${L}/.compiled"
+date --utc > "${W}/.compiled"
 
 # vim: filetype=sh
diff --git a/scripts/builder/build-distclean b/scripts/builder/build-distclean
index eba9c50..585b3d0 100755
--- a/scripts/builder/build-distclean
+++ b/scripts/builder/build-distclean
@@ -1,9 +1,8 @@
 #!/usr/bin/env build
 
 echo "dist-cleaning: ${1}"
-import "${1}"
 
-for dir in "${L}" "${W}" "${D}"; do
+for dir in "$(build query --workdir "${1}")" "$(build query --destdir "${1}")"; do
 	if [ -d "${dir}" ]; then
 		rm -rf "${dir}" &
 	fi
diff --git a/scripts/builder/build-info b/scripts/builder/build-info
deleted file mode 100755
index 4ab3f48..0000000
--- a/scripts/builder/build-info
+++ /dev/null
@@ -1,55 +0,0 @@
-#!/usr/bin/env build
-
-import "${1}"
-shift
-
-# The info action handles a collection of options.
-if [ "$#" -eq "0" ]; then
-	# Default to displaying a package summary
-	set -- --summary
-fi
-case "${1}" in
-(-b|-build-deps|--build-deps)
-	[ -z "${BDEPENDS}" ] || echo "${BDEPENDS}";;
-(-d|-depends|--depends)
-	[ -z "${RDEPENDS}" ] || echo "${RDEPENDS}";;
-(-n|-name|--name)
-	echo "${NAME}";;
-(-d|-description|--description)
-	echo "${DESCRIPTION}";;
-(-v|--version|--version)
-	echo "${VERSION}";;
-(-u|-source-uri|--src-uri)
-	echo "${SOURCE_URI}";;
-(-s|-summary|--summary)
-	echo "Name:		${NAME}"
-	echo "Version:	${VERSION}"
-	if [ -d "${BUILDER_TOPDIR}/packages/${NAME}/souce" ]; then
-		echo "Source:		${BUILDER_TOPDIR}/packages/${NAME}/souce"
-	else
-		echo "Source:		${SOURCE_URI}"
-	fi
-	if [ ! -z "${RDEPENDS}" ]; then
-		echo "Depends:		${RDEPENDS}"
-	fi
-	if [ ! -z "${BDEPENDS}" ]; then
-		echo "BuildDeps:	${BDEPENDS}"
-	fi
-
-	cat <<-EOF
-
-	${DESCRIPTION}
-	EOF
-	;;
-
-(-*)	error "unknown info request '${1}'"
-	echo "try '${0##*/} --help'" >&2
-	exit 1
-	;;
-(*)	error "unhandled argument '${1}'"
-	echo "try '${0##*/} --help'" >&2
-	exit 1
-	;;
-esac
-
-# vim: filetype=sh
diff --git a/scripts/builder/build-install b/scripts/builder/build-install
index b34cb3b..f71acef 100755
--- a/scripts/builder/build-install
+++ b/scripts/builder/build-install
@@ -1,12 +1,16 @@
 #!/usr/bin/env build
 
 echo "installing: ${1}"
-import "${1}"
+eval $(build query --environ "${1}")
+
+# FIXME this should be taken care of by the build config
+if [ -z "${ARCHIVE_FORMAT}" ]; then
+	ARCHIVE_FORMAT="tar.bz2"
+fi
 
-ARCHIVE_FORMAT="tar.bz2"
 [ -f "${BUILDER_ATFDIR}/${NAME}-${VERSION}.${ARCHIVE_FORMAT}" ] || die "archive does not exist for package '${NAME}'"
-if [ ! -d "${BUILDER_SYSROOT}" ]; then
-	mkdir -p "${BUILDER_SYSROOT}" || die "failed to create system root @ '${BUILDER_SYSROOT}'"
+if [ ! -d "${SYSROOT}" ]; then
+	mkdir -p "${SYSROOT}" || die "failed to create system root @ '${SYSROOT}'"
 fi
 
 # FIXME the builder configs should decide the binpkg archive format.
@@ -16,7 +20,7 @@ case "${ARCHIVE_FORMAT}" in
 (*)		die "unsupported archive format '${ARCHIVE_FORMAT}'";;
 esac
 
-cd "${BUILDER_SYSROOT}" && ${ARCHIVE_DECOMPRESSOR} "${BUILDER_ATFDIR}/${NAME}-${VERSION}.${ARCHIVE_FORMAT}" | tar x
-cp -a "${L}/.compiled" "${L}/.installed"
+cd "${SYSROOT}" && ${ARCHIVE_DECOMPRESSOR} "${BUILDER_ATFDIR}/${NAME}-${VERSION}.${ARCHIVE_FORMAT}" | tar x
+cp -a "${W}/.compiled" "${W}/.installed"
 
 # vim: filetype=sh
diff --git a/scripts/builder/build-makedeps b/scripts/builder/build-makedeps
index 20e7797..fca772f 100755
--- a/scripts/builder/build-makedeps
+++ b/scripts/builder/build-makedeps
@@ -1,98 +1,110 @@
 #!/usr/bin/env build
-
-PACKAGES=
-PACKAGES_SYNC=
-PACKAGES_CLEAN=
-PACKAGES_COMPILE=
-PACKAGES_ARCHIVE=
-PACKAGES_INSTALL=
-PACKAGES_DISTCLEAN=
-for package in ${BUILDER_PKGDIR}/*/Buildrules; do
-	[ -f "${package}" ] || continue
-	package="${package%%/Buildrules}"
-	package="${package##*/}"
-	PACKAGES="${PACKAGES} ${package}"
-	PACKAGES_SYNC="${PACKAGES_SYNC} ${package}_sync"
-	PACKAGES_CLEAN="${PACKAGES_CLEAN} ${package}_clean"
-	PACKAGES_COMPILE="${PACKAGES_COMPILE} ${package}_compile"
-	PACKAGES_ARCHIVE="${PACKAGES_ARCHIVE} ${package}_archive"
-	PACKAGES_INSTALL="${PACKAGES_INSTALL} ${package}_install"
-	PACKAGES_DISTCLEAN="${PACKAGES_DISTCLEAN} ${package}_distclean"
-done
-
 cat >"${BUILDER_MAKEFILE}" <<EOF
 ##
 # Some generic catchall rules
-all: ${PACKAGES_ARCHIVE}
-all_sync: ${PACKAGES_SYNC}
-all_clean: ${PACKAGES_CLEAN} sysroot_clean
-all_distclean: ${PACKAGES_DISTCLEAN} sysroot_clean artifacts_clean
-all_compile: ${PACKAGES_COMPILE}
-all_archive: ${PACKAGES_ARCHIVE}
-all_install: ${PACKAGES_INSTALL}
+all: packages_archive
+all_sync: packages_sync
+all_clean: packages_clean sysroot_clean
+all_distclean: packages_distclean sysroot_clean artifacts_clean tooldir_clean
+all_compile: packages_compile
+all_archive: packages_archive
+all_install: packages_install
 all_makedeps:
 
 sysroot_clean:
-	@if [ -d "${BUILDER_SYSROOT}" ]; then echo cleaning: sysroot;rm -rf "${BUILDER_SYSROOT}";fi
-sources_clean:
-	@if [ -d "${BUILDER_SRCDIR}" ]; then echo cleaning: sources;rm -rf "${BUILDER_SRCDIR}";fi
+	@if [ -d "${SYSROOT}" ]; then echo cleaning: sysroot;rm -rf "${SYSROOT}";fi
+tooldir_clean:
+	@if [ -d "${TOOLDIR}" ]; then echo cleaning: sysroot;rm -rf "${TOOLDIR}";fi
 artifacts_clean:
 	@if [ -d "${BUILDER_ATFDIR}" ]; then echo cleaning: artifacts;rm -rf "${BUILDER_ATFDIR}";fi
 
+
 EOF
 
-for package in ${PACKAGES}; do
-	# If the package defines itself as a toolchain component then we unset
-	# TOOLCHAIN, else we set TOOLCHAIN to gcc to be included in the
-	# BDEPENDS
-	TOOLCHAIN=
-	import "${package}"
-	if [ -z "${TOOLCHAIN}" ]; then
-		TOOLCHAIN="gcc"
-	else
-		TOOLCHAIN=
+PACKAGES=
+PACKAGES_SYNC=
+PACKAGES_CLEAN=
+PACKAGES_COMPILE=
+PACKAGES_ARCHIVE=
+PACKAGES_INSTALL=
+PACKAGES_DISTCLEAN=
+for package in $(cd "${BUILDER_PKGDIR}" && echo */*); do
+	if ! eval $(build query --environ "${package}"); then
+		die "in package '${package}'"
 	fi
 
+	package_make="$(echo "${package}"|tr '/' '_')"
 	package_archive="${BUILDER_ATFDIR}/${NAME}-${VERSION}.${ARCHIVE_FORMAT}"
-	package_rule="${BUILDER_PKGDIR}/${NAME}/Buildrules"
-	package_logdir="${BUILDER_PKGDIR}/${NAME}/log"
-	package_install="${package_logdir}/.installed"
-	package_compile="${package_logdir}/.compiled"
-	package_sync="${package_logdir}/.synced"
+	package_rulesfile="${RULESFILE}"
+	package_logdir="${L}"
+	package_install="${W}/.installed"
+	package_compile="${W}/.compiled"
+	package_sync="${W}/.synced"
 	# FIXME we need to deal with package_source as well
 
+	# This loop can end up being fairly costly if we have to fire up
+	# build-query, particularly when dealing with a large number of
+	# packages.  So we do some FS level checks first in hopes of avoiding
+	# it and improving performance.
 	package_deps=
-	for package in ${TOOLCHAIN} ${BDEPENDS}; do
-		package_deps="${package_deps} ${BUILDER_PKGDIR}/${package}/log/.installed"
+	for pkg_dep in ${BDEPENDS}; do
+		if [ ! -d "${BUILDER_PKGDIR}/${pkg_dep}" ]; then
+			if [ ! -d "${BUILDER_PKGDIR}/${PROJECT_NAME}/${pkg_dep}" ]; then
+				if ! build query --exists "${pkg_dep}"; then
+					die "bad BDEPENDS in package '${package}'"
+				fi
+			elif [ ! -f "${BUILDER_PKGDIR}/${PROJECT_NAME}/${pkg_dep}/Buildrules" ]; then
+				die "no Buildrules for '${pkg_dep}'"
+			fi
+		elif [ ! -f "${BUILDER_PKGDIR}/${pkg_dep}/Buildrules" ]; then
+			die "no Buildrules for '${pkg_dep}'"
+		fi
+		pkg_dep="$(echo "${pkg_dep}"|tr '/' '_')"
+		package_deps="${package_deps} ${pkg_dep}_install"
 	done
 
 cat <<EOF
 ##
-# ${NAME} - ${DESCRIPTION}
-${NAME}: ${package_archive}
-${NAME}_install: ${package_install}
-${NAME}_archive: ${package_archive}
-${NAME}_compile: ${package_compile}
-${NAME}_sync: ${package_sync}
-${NAME}_makedeps:
-${NAME}_clean:
-	@build-clean ${NAME}
-${NAME}_distclean:
-	@build-distclean ${NAME}
-
+# ${CATEGORY}/${NAME} - ${DESCRIPTION}
+${package_make}: ${package_archive}
+${package_make}_install: ${package_install}
+${package_make}_archive: ${package_archive}
+${package_make}_compile: ${package_compile}
+${package_make}_sync: ${package_sync}
+${package_make}_makedeps:
+${package_make}_clean:
+	@build-clean ${CATEGORY}/${NAME}
+${package_make}_distclean:
+	@build-distclean ${CATEGORY}/${NAME}
 ${package_install}: ${package_archive}
-	@build-install ${NAME}
-
+	@build-install ${CATEGORY}/${NAME}
 ${package_archive}: ${package_compile}
-	@build-archive ${NAME}
-
+	@build-archive ${CATEGORY}/${NAME}
 ${package_compile}: ${package_sync}${package_deps}
-	@build-compile ${NAME}
-
+	@build-compile ${CATEGORY}/${NAME}
 ${package_sync}: ${package_rule}
-	@build-sync ${NAME}
+	@build-sync ${CATEGORY}/${NAME}
 
 EOF
+
+	if [ "${CATEGORY}" = "${PROJECT_NAME}" ]; then
+		PACKAGES="${PACKAGES} ${package_make}"
+		PACKAGES_SYNC="${PACKAGES_SYNC} ${package_make}_sync"
+		PACKAGES_CLEAN="${PACKAGES_CLEAN} ${package_make}_clean"
+		PACKAGES_COMPILE="${PACKAGES_COMPILE} ${package_make}_compile"
+		PACKAGES_ARCHIVE="${PACKAGES_ARCHIVE} ${package_make}_archive"
+		PACKAGES_INSTALL="${PACKAGES_INSTALL} ${package_make}_install"
+		PACKAGES_DISTCLEAN="${PACKAGES_DISTCLEAN} ${package_make}_distclean"
+	fi
 done >> "${BUILDER_MAKEFILE}"
 
+cat<<EOF >> "${BUILDER_MAKEFILE}"
+packages_sync: ${PACKAGES_SYNC}
+packages_clean: ${PACKAGES_CLEAN}
+packages_compile: ${PACKAGES_COMPILE}
+packages_archive: ${PACKAGES_ARCHIVE}
+packages_install: ${PACKAGES_INSTALL}
+packages_distclean: ${PACKAGES_DISTCLEAN}
+EOF
+
 # vim: filetype=sh
diff --git a/scripts/builder/build-query b/scripts/builder/build-query
new file mode 100755
index 0000000..22b45fa
--- /dev/null
+++ b/scripts/builder/build-query
@@ -0,0 +1,258 @@
+#!/usr/bin/env build
+
+parse_pkg_name()
+{
+	# Only allow a single '/' in the name
+	if [ "1${1##*/}" != "1${1#*/}" ]; then
+		return 1
+	fi
+
+	if [ "2${1#*/}" != "2${1}" ]; then
+		echo -n "${1}"
+	else
+		echo -n "${PROJECT_NAME}/${1}"
+	fi
+}
+
+parse_name()
+{
+	if ! parse_pkg_name "${1}" > /dev/null 2>&1; then
+		return "$?"
+	fi
+
+	set -- "$(parse_pkg_name "${1}")"
+	echo -n "${1#*/}"
+}
+
+parse_category()
+{
+	if ! parse_pkg_name "${1}" > /dev/null 2>&1; then
+		return "$?"
+	fi
+
+	set -- "$(parse_pkg_name "${1}")"
+	echo -n "${1%/*}"
+}
+
+QUERY_ACTION="summary"
+
+while [ "$#" -gt "0" ]; do
+	case "${1}" in
+	(-B|-build-deps|--build-deps)
+		QUERY_ACTION="bdeps";;
+	(-c|-category|--category)
+		QUERY_ACTIONS="category";;
+	(-d|-description|--description)
+		QUERY_ACTION="descr";;
+	(-D|-destdir|--destdir)
+		QUERY_ACTION="destdir";;
+	(--exists)
+		QUERY_ACTION="exists";;
+	(-e|-envdir|--envdir)
+		QUERY_ACTION="envdir";;
+	(-E|-environ|--environ)
+		QUERY_ACTION="environ";;
+	(-f|-filesdir|--filesdir)
+		QUERY_ACTION="filesdir";;
+	(-l|-logdir|--logdir)
+		QUERY_ACTION="logdir";;
+	(-n|-name|--name)
+		QUERY_ACTION="name";;
+	(-N|-pkgname|--pkgname)
+		QUERY_ACTION="pkgname";;
+	(-p|-patches|--patches)
+		QUERY_ACTION="patches";;
+	(-P|-pkgdir|--pkgdir)
+		QUERY_ACTION="pkgdir";;
+	(-r|-rulefile|--rulesfile)
+		QUERY_ACTION="rulesfile";;
+	(-R|-depends|--depends)
+		QUERY_ACTION="rdeps";;
+	(-s|-srcdir|--srcdir)
+		QUERY_ACTION="srcdir";;
+	(-S|-summary|--summary)
+		QUERY_ACTION="summary";;
+	(-t|-tmpdir|--tmpdir)
+		QUERY_ACTION="tmpdir";;
+	(-u|-source-uri|--src-uri)
+		QUERY_ACTION="src_uri";;
+	(-v|-version|--version)
+		QUERY_ACTION="version";;
+	(-V|-var|--var)
+		shift
+		if [ "$#" -lt "1" ]; then
+			error "no variable specified"
+			echo "try '${##*//} --help'" >&2
+			exit 1
+		fi
+
+		QUERY_ACTION="var"
+		QUERY_VAR="${1}"
+		;;
+	(-w|-workdir|--workdir)
+		QUERY_ACTION="workdir";;
+	(-*)	error "unknown query '${1}'"
+		echo "try '${0##*/} --help'" >&2
+		exit 1
+		;;
+	(*)	break;;
+	esac
+	shift
+done
+
+if [ "$#" -eq "0" ]; then
+	die "no package specified"
+fi
+
+# We can aquire this data before we bother importing anything
+NAME="$(parse_name "${1}")"
+CATEGORY="$(parse_category "${1}")"
+PKG_NAME="${CATEGORY}/${NAME}"
+
+if [ ! -d "${BUILDER_PKGDIR}/${PKG_NAME}" ]; then
+	die "no such package '${1}'"
+fi
+
+RULESFILE="${BUILDER_PKGDIR}/${CATEGORY}/${NAME}/Buildrules"
+if [ ! -f "${RULESFILE}" ]; then
+	die "no rulesfile for package '${1}'"
+fi
+
+export NAME CATEGORY PKG_NAME RULESFILE
+
+shift
+
+# These variables are used by the Buildrules and fundmentally make up the
+# majority of their environ data
+F="${BUILDER_PKGDIR}/${CATEGORY}/${NAME}/files"
+W="${BUILDER_PKGDIR}/${CATEGORY}/${NAME}/build"
+L="${W}/log"
+E="${W}/env"
+T="${W}/tmp"
+D="${W}/install"
+
+export F W L E T D
+
+# These requests can be answered without sourcing the Buildrules, everything
+# else needs the Rulesfile sourced in
+case "${QUERY_ACTION}" in
+(exists)	exit 0;; # Simply break out
+(name)		echo "${NAME}";exit 0;;
+(category)	echo "${CATEGORY}";exit 0;;
+(pkgname)	echo "${CATEGORY}/${NAME}";exit 0;;
+(pkgdir)	echo "${BUILDER_PKGDIR}/${CATEGORY}/${NAME}";exit 0;;
+(rulesfile)	echo "${RULESFILE}";exit 0;;
+(filesdir)	echo "${F}";exit 0;;
+(workdir)	echo "${W}";exit 0;;
+(logdir)	echo "${L}";exit 0;;
+(envdir)	echo "${E}";exit 0;;
+(tmpdir)	echo "${T}";exit 0;;
+(destdir)	echo "${D}";exit 0;;
+esac
+
+# These variables are only set within a Rulesfile and thus need to be cleared
+# before sourcing it in.
+VERSION=
+DESCRIPTION=
+SOURCE_URI=
+PATCHES=
+RDEPENDS=
+BDEPENDS=
+
+. "${RULESFILE}"
+
+# Allow the developer to hijack the SRC_URI with a checked out repository
+if [ -d "${BUILDER_PKGDIR}/${CATEGORY}/${NAME}/source" ]; then
+	SOURCE_URI="file://${BUILDER_PKGDIR}/${CATEGORY}/${NAME}/source"
+fi
+export VERSION DESCRIPTION SOURCE_URI PATCHES BDEPENDS RDEPENDS
+
+# Ironically, the source working directory can't be assigned until we source in
+# the Buildrules due to the dependancy on the VERSION
+S="${W}/${NAME}-${VERSION}"
+export S
+
+case "${QUERY_ACTION}" in
+(srcdir)	echo "${S}";;
+(bdeps)		echo "${BDEPENDS}";;
+(rdeps)		echo "${RDEPENDS}";;
+(descr)		echo "${DESCRIPTION}";;
+(version)	echo "${VERSION}";;
+(patches)	echo "${PATCHES}";;
+
+# Allow the caller to specify the variable to report.
+# FIXME may need to protect our existing environ from being poked.
+(var)		if [ -z "${QUERY_VAR}" ]; then
+			die "no variable specified"
+		fi
+		eval "echo \"\$${QUERY_VAR}\"";;
+
+# All the fun environ data necessary for grabbing a single package.  We ALWAYS
+# report all the variables, even if unset.  This allows a caller to use this
+# command to set their own environ and automagically clear any variables which
+# are already set in their environment.
+(environ)
+		cat<<-EOF
+		PROJECT_NAME="${PROJECT_NAME}"
+		TOPDIR="${TOPDIR}"
+		TOOLDIR="${TOOLDIR}"
+		SYSROOT="${SYSROOT}"
+		CHOST="${CHOST}"
+		ARCH="${ARCH}"
+		VENDOR="${VENDOR}"
+		PLATFORM="${PLATFORM}"
+		NAME="${NAME}"
+		CATEGORY="${CATEGORY}"
+		RULESFILE="${RULESFILE}"
+		VERSION="${VERSION}"
+		DESCRIPTION="${DESCRIPTION}"
+		SOURCE_URI="${SOURCE_URI}"
+		EOF
+		if [ ! -z "${PATCHES}" ]; then
+			echo "PATCHES=\"${PATCHES}\""
+		else
+			echo "PATCHES="
+		fi
+		if [ ! -z "${RDEPENDS}" ]; then
+			echo "RDEPENDS=\"${RDEPENDS}\""
+		else
+			echo "RDEPENDS="
+		fi
+		if [ ! -z "${BDEPENDS}" ]; then
+			echo "BDEPENDS=\"${BDEPENDS}\""
+		else
+			echo "BDEPENDS="
+		fi
+		cat<<-EOF
+		F="${F}"
+		W="${W}"
+		L="${L}"
+		E="${E}"
+		T="${T}"
+		D="${D}"
+		S="${S}"
+		EOF
+		;;
+
+# Basic summary command
+(summary)
+		echo "Name:		${CATEGORY}/${NAME}"
+		echo "Version:	${VERSION}"
+		echo "Source:		${SOURCE_URI}"
+		if [ ! -z "${RDEPENDS}" ]; then
+			echo "Depends:		${RDEPENDS}"
+		fi
+		if [ ! -z "${BDEPENDS}" ]; then
+			echo "BuildDeps:	${BDEPENDS}"
+		fi
+
+		cat <<-EOF
+
+		${DESCRIPTION}
+		EOF
+		;;
+
+(*)		die "unhandled query action '${QUERY_ACTION}'";;
+esac
+
+# vim: filetype=sh
diff --git a/scripts/builder/build-sync b/scripts/builder/build-sync
index 0627ace..c9cceba 100755
--- a/scripts/builder/build-sync
+++ b/scripts/builder/build-sync
@@ -1,7 +1,8 @@
 #!/usr/bin/env build
 
 echo "syncing: ${1}"
-import "${1}"
+
+eval $(build query --environ "${1}")
 
 build_sync_git()
 {
@@ -120,6 +121,6 @@ if [ ! -z "${PATCHES}" ]; then
 	done
 fi
 
-date --utc > "${L}/.synced"
+date --utc > "${W}/.synced"
 
 # vim: filetype=sh