Makefile.linux

# -*- mode: makefile -*-
# Generated for linux at Fri Dec 21 07:44:44 2012.
# DO NOT EDIT! IT WILL BE OVERWRITTEN ON NEXT RUN!
#
# Command: SCRIPTS/buildbot/make-generator.py -o Makefile.linux linux
#
# Packages used:
#   - efl
#   - e_dbus
#   - eeze
#   - python-evas
#   - python-ecore
#   - python-e_dbus
#   - efx
#   - edbus
#   - efreet
#   - edje
#   - python-edje
#   - emotion
#   - elementary
#   - terminology
#   - e
#   - clouseau

SRCROOT = $(shell pwd)
BUILDROOT = $(shell pwd)/build
INSTALLROOT = $(shell pwd)/install
MAKEOPTS = --print-directory -j6
V=@

.DEFAULT: missing-target
.PHONY: missing-target help all clean efl-compile efl-clean efl-dependencies efl-install efl-test efl-doc efl-distcheck efl-all-users-compile efl-direct-users-compile e_dbus-compile e_dbus-clean e_dbus-dependencies e_dbus-install e_dbus-test e_dbus-doc e_dbus-distcheck e_dbus-all-users-compile e_dbus-direct-users-compile eeze-compile eeze-clean eeze-dependencies eeze-install eeze-test eeze-doc eeze-distcheck eeze-all-users-compile eeze-direct-users-compile python-evas-compile python-evas-clean python-evas-dependencies python-evas-install python-evas-test python-evas-doc python-evas-distcheck python-evas-all-users-compile python-evas-direct-users-compile python-ecore-compile python-ecore-clean python-ecore-dependencies python-ecore-install python-ecore-test python-ecore-doc python-ecore-distcheck python-ecore-all-users-compile python-ecore-direct-users-compile python-e_dbus-compile python-e_dbus-clean python-e_dbus-dependencies python-e_dbus-install python-e_dbus-test python-e_dbus-doc python-e_dbus-distcheck python-e_dbus-all-users-compile python-e_dbus-direct-users-compile efx-compile efx-clean efx-dependencies efx-install efx-test efx-doc efx-distcheck efx-all-users-compile efx-direct-users-compile edbus-compile edbus-clean edbus-dependencies edbus-install edbus-test edbus-doc edbus-distcheck edbus-all-users-compile edbus-direct-users-compile efreet-compile efreet-clean efreet-dependencies efreet-install efreet-test efreet-doc efreet-distcheck efreet-all-users-compile efreet-direct-users-compile edje-compile edje-clean edje-dependencies edje-install edje-test edje-doc edje-distcheck edje-all-users-compile edje-direct-users-compile python-edje-compile python-edje-clean python-edje-dependencies python-edje-install python-edje-test python-edje-doc python-edje-distcheck python-edje-all-users-compile python-edje-direct-users-compile emotion-compile emotion-clean emotion-dependencies emotion-install emotion-test emotion-doc emotion-distcheck emotion-all-users-compile emotion-direct-users-compile elementary-compile elementary-clean elementary-dependencies elementary-install elementary-test elementary-doc elementary-distcheck elementary-all-users-compile elementary-direct-users-compile terminology-compile terminology-clean terminology-dependencies terminology-install terminology-test terminology-doc terminology-distcheck terminology-all-users-compile terminology-direct-users-compile e-compile e-clean e-dependencies e-install e-test e-doc e-distcheck e-all-users-compile e-direct-users-compile clouseau-compile clouseau-clean clouseau-dependencies clouseau-install clouseau-test clouseau-doc clouseau-distcheck clouseau-all-users-compile clouseau-direct-users-compile

missing-target:
	@echo "Missing target."
	@exit 1

help:
	@echo "Variables:"
	@echo "   SRCROOT=absolute-path        where sources are located."
	@echo "   BUILDROOT=absolute-path      where to store built files."
	@echo "   INSTALLROOT=absolute-path    where to install built files."
	@echo ""
	@echo "Toplevel Targets:"
	@echo "   clean                        remove all built files."
	@echo "   all                          compile all packages."
	@echo "   test                         test all packages."
	@echo "   doc                          generate docs for all packages."
	@echo "   distcheck                    check distribution of all packages."
	@echo ""
	@echo "Package Targets:"
	@echo "   PACKAGE-compile              compile package."
	@echo "   PACKAGE-clean                remove all built files."
	@echo "   PACKAGE-dependencies         compile and install package dependencies."
	@echo "   PACKAGE-install              install package to \$$INSTALLROOT"
	@echo "   PACKAGE-test                 test package."
	@echo "   PACKAGE-doc                  generated documentation."
	@echo "   PACKAGE-distcheck            check package distribution."
	@echo "   PACKAGE-all-users-compile    compile all users of package."
	@echo "   PACKAGE-direct-users-compile compile all direct users of package."
	@echo ""
	@echo "Known packages:"
	@echo "   efl e_dbus eeze python-evas python-ecore python-e_dbus efx edbus efreet edje python-edje emotion elementary terminology e clouseau"
	@echo ""

all: efl-compile e_dbus-compile eeze-compile python-evas-compile python-ecore-compile python-e_dbus-compile efx-compile edbus-compile efreet-compile edje-compile python-edje-compile emotion-compile elementary-compile terminology-compile e-compile clouseau-compile
clean: efl-clean e_dbus-clean eeze-clean python-evas-clean python-ecore-clean python-e_dbus-clean efx-clean edbus-clean efreet-clean edje-clean python-edje-clean emotion-clean elementary-clean terminology-clean e-clean clouseau-clean
test: efl-test e_dbus-test eeze-test python-evas-test python-ecore-test python-e_dbus-test efx-test edbus-test efreet-test edje-test python-edje-test emotion-test elementary-test terminology-test e-test clouseau-test
doc: efl-doc e_dbus-doc eeze-doc python-evas-doc python-ecore-doc python-e_dbus-doc efx-doc edbus-doc efreet-doc edje-doc python-edje-doc emotion-doc elementary-doc terminology-doc e-doc clouseau-doc
distcheck: efl-distcheck e_dbus-distcheck eeze-distcheck python-evas-distcheck python-ecore-distcheck python-e_dbus-distcheck efx-distcheck edbus-distcheck efreet-distcheck edje-distcheck python-edje-distcheck emotion-distcheck elementary-distcheck terminology-distcheck e-distcheck clouseau-distcheck

########################################################################
# efl rules
efl-dependencies: $(BUILDROOT)/efl/stamps/dependencies 
$(BUILDROOT)/efl/stamps/dependencies: 
	$(V)mkdir -p $(BUILDROOT)/efl/stamps
	touch $(BUILDROOT)/efl/stamps/dependencies

efl-clean:
	if test -d $(BUILDROOT)/efl/compile; then chmod -R u+w $(BUILDROOT)/efl/compile; fi
	rm -fr $(BUILDROOT)/efl/compile
	rm -fr $(BUILDROOT)/efl/stamps

$(BUILDROOT)/efl/stamps/autogen: $(SRCROOT)/efl/autogen.sh $(SRCROOT)/efl/configure.ac
	$(V)echo "Running 'autogen.sh' for efl..."
	$(V)rm -f $(BUILDROOT)/efl/stamps/autogen
	cd $(SRCROOT)/efl && NOCONFIGURE=1 ./autogen.sh
	$(V)mkdir -p $(BUILDROOT)/efl/stamps
	touch $(BUILDROOT)/efl/stamps/autogen
	$(V)echo "Success running 'autogen.sh' for efl."

$(BUILDROOT)/efl/stamps/configure: $(BUILDROOT)/efl/stamps/autogen $(BUILDROOT)/efl/stamps/dependencies
	$(V)echo "Configuring efl..."
	$(V)rm -f $(BUILDROOT)/efl/stamps/configure
	$(V)mkdir -p $(BUILDROOT)/efl/compile
	export PATH="$(INSTALLROOT)/bin:$${PATH}";\
	export PKG_CONFIG_PATH="$(INSTALLROOT)/lib/pkgconfig";\
	export CXXFLAGS="$${CXXFLAGS} -O2 -Wall -Wextra -Wshadow -fvisibility=hidden -fdata-sections -ffunction-sections";\
	export CFLAGS="$${CFLAGS} -O2 -Wall -Wextra -Wshadow -fvisibility=hidden -fdata-sections -ffunction-sections";\
	export LDFLAGS="$${LDFLAGS} -fvisibility=hidden -fdata-sections -ffunction-sections -Wl,--gc-sections -Wl,--as-needed";\
	cd $(BUILDROOT)/efl/compile && \
	$(SRCROOT)/efl/configure --prefix=$(INSTALLROOT) --enable-doc \
		--with-tests=coverage
	$(V)mkdir -p $(BUILDROOT)/efl/stamps
	touch $(BUILDROOT)/efl/stamps/configure
	$(V)echo "Success configuring efl."

$(BUILDROOT)/efl/stamps/compile: $(BUILDROOT)/efl/stamps/configure efl-compile
efl-compile: $(BUILDROOT)/efl/stamps/configure
	$(V)echo "Compiling efl..."
	$(V)rm -f $(BUILDROOT)/efl/stamps/compile-updated
	$(V)mkdir -p $(BUILDROOT)/efl/stamps
	$(V)if make --dry-run $(MAKEOPTS) all -C $(BUILDROOT)/efl/compile 2>/dev/null | grep -e 'libtool ' >/dev/null 2>/dev/null; then\
		touch $(BUILDROOT)/efl/stamps/compile-updated;\
	fi
	$(V)if test -f $(BUILDROOT)/efl/stamps/compile-updated; then\
		echo "make $(MAKEOPTS) all -C $(BUILDROOT)/efl/compile";\
		export PATH="$(INSTALLROOT)/bin:$${PATH}";\
	export PKG_CONFIG_PATH="$(INSTALLROOT)/lib/pkgconfig";\
	export CXXFLAGS="$${CXXFLAGS} -O2 -Wall -Wextra -Wshadow -fvisibility=hidden -fdata-sections -ffunction-sections";\
	export CFLAGS="$${CFLAGS} -O2 -Wall -Wextra -Wshadow -fvisibility=hidden -fdata-sections -ffunction-sections";\
	export LDFLAGS="$${LDFLAGS} -fvisibility=hidden -fdata-sections -ffunction-sections -Wl,--gc-sections -Wl,--as-needed";\
	make $(MAKEOPTS) all -C $(BUILDROOT)/efl/compile;\
	else\
		echo "efl is up to date.";\
	fi
	$(V)if test ! -f $(BUILDROOT)/efl/stamps/compile -o -f $(BUILDROOT)/efl/stamps/compile-updated; then\
		touch $(BUILDROOT)/efl/stamps/compile;\
		echo "Compile updated, needs reinstall.";\
	fi
	$(V)echo "Success compiling efl."

$(BUILDROOT)/efl/stamps/install: $(BUILDROOT)/efl/stamps/compile efl-install
efl-install: $(BUILDROOT)/efl/stamps/compile
	$(V)echo "Installing efl..."
	$(V)if test ! -f $(BUILDROOT)/efl/stamps/install -o $(BUILDROOT)/efl/stamps/compile -nt $(BUILDROOT)/efl/stamps/install; then\
		rm -f $(BUILDROOT)/efl/stamps/install;\
		echo "make $(MAKEOPTS) install -C $(BUILDROOT)/efl/compile";\
		export PATH="$(INSTALLROOT)/bin:$${PATH}";\
	export PKG_CONFIG_PATH="$(INSTALLROOT)/lib/pkgconfig";\
	export CXXFLAGS="$${CXXFLAGS} -O2 -Wall -Wextra -Wshadow -fvisibility=hidden -fdata-sections -ffunction-sections";\
	export CFLAGS="$${CFLAGS} -O2 -Wall -Wextra -Wshadow -fvisibility=hidden -fdata-sections -ffunction-sections";\
	export LDFLAGS="$${LDFLAGS} -fvisibility=hidden -fdata-sections -ffunction-sections -Wl,--gc-sections -Wl,--as-needed";\
	make $(MAKEOPTS) install -C $(BUILDROOT)/efl/compile;\
		mkdir -p $(BUILDROOT)/efl/stamps;\
		touch $(BUILDROOT)/efl/stamps/install;\
	else\
		echo "efl did not change, not need to reinstall.";\
	fi
	$(V)echo "Success installing efl."

$(BUILDROOT)/efl/stamps/test: $(BUILDROOT)/efl/stamps/compile efl-test
efl-test: $(BUILDROOT)/efl/stamps/compile
	$(V)echo "Testing (make check) efl..."
	$(V)rm -f $(BUILDROOT)/efl/stamps/test
	export PATH="$(INSTALLROOT)/bin:$${PATH}";\
	export PKG_CONFIG_PATH="$(INSTALLROOT)/lib/pkgconfig";\
	export CXXFLAGS="$${CXXFLAGS} -O2 -Wall -Wextra -Wshadow -fvisibility=hidden -fdata-sections -ffunction-sections";\
	export CFLAGS="$${CFLAGS} -O2 -Wall -Wextra -Wshadow -fvisibility=hidden -fdata-sections -ffunction-sections";\
	export LDFLAGS="$${LDFLAGS} -fvisibility=hidden -fdata-sections -ffunction-sections -Wl,--gc-sections -Wl,--as-needed";\
	dbus-launch make $(MAKEOPTS) check -C $(BUILDROOT)/efl/compile
	$(V)mkdir -p $(BUILDROOT)/efl/stamps
	touch $(BUILDROOT)/efl/stamps/test
	$(V)echo "Success testing (make check) efl."

$(BUILDROOT)/efl/stamps/doc: $(BUILDROOT)/efl/stamps/compile efl-doc
efl-doc: $(BUILDROOT)/efl/stamps/compile
	$(V)echo "Generating documentation (make doc) efl..."
	$(V)rm -f $(BUILDROOT)/efl/stamps/doc
	export PATH="$(INSTALLROOT)/bin:$${PATH}";\
	export PKG_CONFIG_PATH="$(INSTALLROOT)/lib/pkgconfig";\
	export CXXFLAGS="$${CXXFLAGS} -O2 -Wall -Wextra -Wshadow -fvisibility=hidden -fdata-sections -ffunction-sections";\
	export CFLAGS="$${CFLAGS} -O2 -Wall -Wextra -Wshadow -fvisibility=hidden -fdata-sections -ffunction-sections";\
	export LDFLAGS="$${LDFLAGS} -fvisibility=hidden -fdata-sections -ffunction-sections -Wl,--gc-sections -Wl,--as-needed";\
	make $(MAKEOPTS) doc -C $(BUILDROOT)/efl/compile
	$(V)mkdir -p $(BUILDROOT)/efl/stamps
	touch $(BUILDROOT)/efl/stamps/doc
	$(V)echo "Success generating documentation (make doc) efl."

$(BUILDROOT)/efl/stamps/distcheck: $(BUILDROOT)/efl/stamps/compile efl-distcheck
efl-distcheck: $(BUILDROOT)/efl/stamps/compile
	$(V)echo "Checking distribution efl..."
	$(V)rm -f $(BUILDROOT)/efl/stamps/distcheck
	export PATH="$(INSTALLROOT)/bin:$${PATH}";\
	export PKG_CONFIG_PATH="$(INSTALLROOT)/lib/pkgconfig";\
	export CXXFLAGS="$${CXXFLAGS} -O2 -Wall -Wextra -Wshadow -fvisibility=hidden -fdata-sections -ffunction-sections";\
	export CFLAGS="$${CFLAGS} -O2 -Wall -Wextra -Wshadow -fvisibility=hidden -fdata-sections -ffunction-sections";\
	export LDFLAGS="$${LDFLAGS} -fvisibility=hidden -fdata-sections -ffunction-sections -Wl,--gc-sections -Wl,--as-needed";\
	make $(MAKEOPTS) distcheck -C $(BUILDROOT)/efl/compile
	$(V)mkdir -p $(BUILDROOT)/efl/stamps
	touch $(BUILDROOT)/efl/stamps/distcheck
	$(V)echo "Success checking distribution efl."

efl-direct-users-compile: edje-compile emotion-compile edbus-compile efx-compile e-compile python-evas-compile eeze-compile efreet-compile e_dbus-compile elementary-compile python-ecore-compile clouseau-compile terminology-compile

efl-all-users-compile: edje-compile emotion-compile edbus-compile efx-compile e-compile python-evas-compile python-edje-compile eeze-compile efreet-compile e_dbus-compile python-ecore-compile elementary-compile python-e_dbus-compile clouseau-compile terminology-compile

########################################################################
# e_dbus rules
e_dbus-dependencies: $(BUILDROOT)/e_dbus/stamps/dependencies efl-install
$(BUILDROOT)/e_dbus/stamps/dependencies: $(BUILDROOT)/efl/stamps/install
	$(V)mkdir -p $(BUILDROOT)/e_dbus/stamps
	touch $(BUILDROOT)/e_dbus/stamps/dependencies

e_dbus-clean:
	if test -d $(BUILDROOT)/e_dbus/compile; then chmod -R u+w $(BUILDROOT)/e_dbus/compile; fi
	rm -fr $(BUILDROOT)/e_dbus/compile
	rm -fr $(BUILDROOT)/e_dbus/stamps

$(BUILDROOT)/e_dbus/stamps/autogen: $(SRCROOT)/e_dbus/autogen.sh $(SRCROOT)/e_dbus/configure.ac
	$(V)echo "Running 'autogen.sh' for e_dbus..."
	$(V)rm -f $(BUILDROOT)/e_dbus/stamps/autogen
	cd $(SRCROOT)/e_dbus && NOCONFIGURE=1 ./autogen.sh
	$(V)mkdir -p $(BUILDROOT)/e_dbus/stamps
	touch $(BUILDROOT)/e_dbus/stamps/autogen
	$(V)echo "Success running 'autogen.sh' for e_dbus."

$(BUILDROOT)/e_dbus/stamps/configure: $(BUILDROOT)/e_dbus/stamps/autogen $(BUILDROOT)/e_dbus/stamps/dependencies
	$(V)echo "Configuring e_dbus..."
	$(V)rm -f $(BUILDROOT)/e_dbus/stamps/configure
	$(V)mkdir -p $(BUILDROOT)/e_dbus/compile
	export PATH="$(INSTALLROOT)/bin:$${PATH}";\
	export PKG_CONFIG_PATH="$(INSTALLROOT)/lib/pkgconfig";\
	export CXXFLAGS="$${CXXFLAGS} -O2 -Wall -Wextra -Wshadow -fvisibility=hidden -fdata-sections -ffunction-sections";\
	export CFLAGS="$${CFLAGS} -O2 -Wall -Wextra -Wshadow -fvisibility=hidden -fdata-sections -ffunction-sections";\
	export LDFLAGS="$${LDFLAGS} -fvisibility=hidden -fdata-sections -ffunction-sections -Wl,--gc-sections -Wl,--as-needed";\
	cd $(BUILDROOT)/e_dbus/compile && \
	$(SRCROOT)/e_dbus/configure --prefix=$(INSTALLROOT) --enable-doc \
		--enable-ebluez \
		--enable-econnman0_7x \
		--enable-enotify \
		--enable-eofono \
		--enable-eukit
	$(V)mkdir -p $(BUILDROOT)/e_dbus/stamps
	touch $(BUILDROOT)/e_dbus/stamps/configure
	$(V)echo "Success configuring e_dbus."

$(BUILDROOT)/e_dbus/stamps/compile: $(BUILDROOT)/e_dbus/stamps/configure e_dbus-compile
e_dbus-compile: $(BUILDROOT)/e_dbus/stamps/configure
	$(V)echo "Compiling e_dbus..."
	$(V)rm -f $(BUILDROOT)/e_dbus/stamps/compile-updated
	$(V)mkdir -p $(BUILDROOT)/e_dbus/stamps
	$(V)if make --dry-run $(MAKEOPTS) all -C $(BUILDROOT)/e_dbus/compile 2>/dev/null | grep -e 'libtool ' >/dev/null 2>/dev/null; then\
		touch $(BUILDROOT)/e_dbus/stamps/compile-updated;\
	fi
	$(V)if test -f $(BUILDROOT)/e_dbus/stamps/compile-updated; then\
		echo "make $(MAKEOPTS) all -C $(BUILDROOT)/e_dbus/compile";\
		export PATH="$(INSTALLROOT)/bin:$${PATH}";\
	export PKG_CONFIG_PATH="$(INSTALLROOT)/lib/pkgconfig";\
	export CXXFLAGS="$${CXXFLAGS} -O2 -Wall -Wextra -Wshadow -fvisibility=hidden -fdata-sections -ffunction-sections";\
	export CFLAGS="$${CFLAGS} -O2 -Wall -Wextra -Wshadow -fvisibility=hidden -fdata-sections -ffunction-sections";\
	export LDFLAGS="$${LDFLAGS} -fvisibility=hidden -fdata-sections -ffunction-sections -Wl,--gc-sections -Wl,--as-needed";\
	make $(MAKEOPTS) all -C $(BUILDROOT)/e_dbus/compile;\
	else\
		echo "e_dbus is up to date.";\
	fi
	$(V)if test ! -f $(BUILDROOT)/e_dbus/stamps/compile -o -f $(BUILDROOT)/e_dbus/stamps/compile-updated; then\
		touch $(BUILDROOT)/e_dbus/stamps/compile;\
		echo "Compile updated, needs reinstall.";\
	fi
	$(V)echo "Success compiling e_dbus."

$(BUILDROOT)/e_dbus/stamps/install: $(BUILDROOT)/e_dbus/stamps/compile e_dbus-install
e_dbus-install: $(BUILDROOT)/e_dbus/stamps/compile
	$(V)echo "Installing e_dbus..."
	$(V)if test ! -f $(BUILDROOT)/e_dbus/stamps/install -o $(BUILDROOT)/e_dbus/stamps/compile -nt $(BUILDROOT)/e_dbus/stamps/install; then\
		rm -f $(BUILDROOT)/e_dbus/stamps/install;\
		echo "make $(MAKEOPTS) install -C $(BUILDROOT)/e_dbus/compile";\
		export PATH="$(INSTALLROOT)/bin:$${PATH}";\
	export PKG_CONFIG_PATH="$(INSTALLROOT)/lib/pkgconfig";\
	export CXXFLAGS="$${CXXFLAGS} -O2 -Wall -Wextra -Wshadow -fvisibility=hidden -fdata-sections -ffunction-sections";\
	export CFLAGS="$${CFLAGS} -O2 -Wall -Wextra -Wshadow -fvisibility=hidden -fdata-sections -ffunction-sections";\
	export LDFLAGS="$${LDFLAGS} -fvisibility=hidden -fdata-sections -ffunction-sections -Wl,--gc-sections -Wl,--as-needed";\
	make $(MAKEOPTS) install -C $(BUILDROOT)/e_dbus/compile;\
		mkdir -p $(BUILDROOT)/e_dbus/stamps;\
		touch $(BUILDROOT)/e_dbus/stamps/install;\
	else\
		echo "e_dbus did not change, not need to reinstall.";\
	fi
	$(V)echo "Success installing e_dbus."

$(BUILDROOT)/e_dbus/stamps/test: $(BUILDROOT)/e_dbus/stamps/compile e_dbus-test
e_dbus-test: $(BUILDROOT)/e_dbus/stamps/compile
	$(V)mkdir -p $(BUILDROOT)/e_dbus/stamps
	touch $(BUILDROOT)/e_dbus/stamps/test
	$(V)echo 'No test target defined for e_dbus'

$(BUILDROOT)/e_dbus/stamps/doc: $(BUILDROOT)/e_dbus/stamps/compile e_dbus-doc
e_dbus-doc: $(BUILDROOT)/e_dbus/stamps/compile
	$(V)echo "Generating documentation (make doc) e_dbus..."
	$(V)rm -f $(BUILDROOT)/e_dbus/stamps/doc
	export PATH="$(INSTALLROOT)/bin:$${PATH}";\
	export PKG_CONFIG_PATH="$(INSTALLROOT)/lib/pkgconfig";\
	export CXXFLAGS="$${CXXFLAGS} -O2 -Wall -Wextra -Wshadow -fvisibility=hidden -fdata-sections -ffunction-sections";\
	export CFLAGS="$${CFLAGS} -O2 -Wall -Wextra -Wshadow -fvisibility=hidden -fdata-sections -ffunction-sections";\
	export LDFLAGS="$${LDFLAGS} -fvisibility=hidden -fdata-sections -ffunction-sections -Wl,--gc-sections -Wl,--as-needed";\
	make $(MAKEOPTS) doc -C $(BUILDROOT)/e_dbus/compile
	$(V)mkdir -p $(BUILDROOT)/e_dbus/stamps
	touch $(BUILDROOT)/e_dbus/stamps/doc
	$(V)echo "Success generating documentation (make doc) e_dbus."

$(BUILDROOT)/e_dbus/stamps/distcheck: $(BUILDROOT)/e_dbus/stamps/compile e_dbus-distcheck
e_dbus-distcheck: $(BUILDROOT)/e_dbus/stamps/compile
	$(V)echo "Checking distribution e_dbus..."
	$(V)rm -f $(BUILDROOT)/e_dbus/stamps/distcheck
	export PATH="$(INSTALLROOT)/bin:$${PATH}";\
	export PKG_CONFIG_PATH="$(INSTALLROOT)/lib/pkgconfig";\
	export CXXFLAGS="$${CXXFLAGS} -O2 -Wall -Wextra -Wshadow -fvisibility=hidden -fdata-sections -ffunction-sections";\
	export CFLAGS="$${CFLAGS} -O2 -Wall -Wextra -Wshadow -fvisibility=hidden -fdata-sections -ffunction-sections";\
	export LDFLAGS="$${LDFLAGS} -fvisibility=hidden -fdata-sections -ffunction-sections -Wl,--gc-sections -Wl,--as-needed";\
	make $(MAKEOPTS) distcheck -C $(BUILDROOT)/e_dbus/compile
	$(V)mkdir -p $(BUILDROOT)/e_dbus/stamps
	touch $(BUILDROOT)/e_dbus/stamps/distcheck
	$(V)echo "Success checking distribution e_dbus."

e_dbus-direct-users-compile: elementary-compile python-e_dbus-compile e-compile

e_dbus-all-users-compile: elementary-compile python-e_dbus-compile clouseau-compile e-compile terminology-compile

########################################################################
# eeze rules
eeze-dependencies: $(BUILDROOT)/eeze/stamps/dependencies efl-install
$(BUILDROOT)/eeze/stamps/dependencies: $(BUILDROOT)/efl/stamps/install
	$(V)mkdir -p $(BUILDROOT)/eeze/stamps
	touch $(BUILDROOT)/eeze/stamps/dependencies

eeze-clean:
	if test -d $(BUILDROOT)/eeze/compile; then chmod -R u+w $(BUILDROOT)/eeze/compile; fi
	rm -fr $(BUILDROOT)/eeze/compile
	rm -fr $(BUILDROOT)/eeze/stamps

$(BUILDROOT)/eeze/stamps/autogen: $(SRCROOT)/eeze/autogen.sh $(SRCROOT)/eeze/configure.ac
	$(V)echo "Running 'autogen.sh' for eeze..."
	$(V)rm -f $(BUILDROOT)/eeze/stamps/autogen
	cd $(SRCROOT)/eeze && NOCONFIGURE=1 ./autogen.sh
	$(V)mkdir -p $(BUILDROOT)/eeze/stamps
	touch $(BUILDROOT)/eeze/stamps/autogen
	$(V)echo "Success running 'autogen.sh' for eeze."

$(BUILDROOT)/eeze/stamps/configure: $(BUILDROOT)/eeze/stamps/autogen $(BUILDROOT)/eeze/stamps/dependencies
	$(V)echo "Configuring eeze..."
	$(V)rm -f $(BUILDROOT)/eeze/stamps/configure
	$(V)mkdir -p $(BUILDROOT)/eeze/compile
	export PATH="$(INSTALLROOT)/bin:$${PATH}";\
	export PKG_CONFIG_PATH="$(INSTALLROOT)/lib/pkgconfig";\
	export CXXFLAGS="$${CXXFLAGS} -O2 -Wall -Wextra -Wshadow -fvisibility=hidden -fdata-sections -ffunction-sections";\
	export CFLAGS="$${CFLAGS} -O2 -Wall -Wextra -Wshadow -fvisibility=hidden -fdata-sections -ffunction-sections";\
	export LDFLAGS="$${LDFLAGS} -fvisibility=hidden -fdata-sections -ffunction-sections -Wl,--gc-sections -Wl,--as-needed";\
	cd $(BUILDROOT)/eeze/compile && \
	$(SRCROOT)/eeze/configure --prefix=$(INSTALLROOT) --enable-doc \
		--enable-tests \
		--with-mount \
		--with-umount \
		--with-eject
	$(V)mkdir -p $(BUILDROOT)/eeze/stamps
	touch $(BUILDROOT)/eeze/stamps/configure
	$(V)echo "Success configuring eeze."

$(BUILDROOT)/eeze/stamps/compile: $(BUILDROOT)/eeze/stamps/configure eeze-compile
eeze-compile: $(BUILDROOT)/eeze/stamps/configure
	$(V)echo "Compiling eeze..."
	$(V)rm -f $(BUILDROOT)/eeze/stamps/compile-updated
	$(V)mkdir -p $(BUILDROOT)/eeze/stamps
	$(V)if make --dry-run $(MAKEOPTS) all -C $(BUILDROOT)/eeze/compile 2>/dev/null | grep -e 'libtool ' >/dev/null 2>/dev/null; then\
		touch $(BUILDROOT)/eeze/stamps/compile-updated;\
	fi
	$(V)if test -f $(BUILDROOT)/eeze/stamps/compile-updated; then\
		echo "make $(MAKEOPTS) all -C $(BUILDROOT)/eeze/compile";\
		export PATH="$(INSTALLROOT)/bin:$${PATH}";\
	export PKG_CONFIG_PATH="$(INSTALLROOT)/lib/pkgconfig";\
	export CXXFLAGS="$${CXXFLAGS} -O2 -Wall -Wextra -Wshadow -fvisibility=hidden -fdata-sections -ffunction-sections";\
	export CFLAGS="$${CFLAGS} -O2 -Wall -Wextra -Wshadow -fvisibility=hidden -fdata-sections -ffunction-sections";\
	export LDFLAGS="$${LDFLAGS} -fvisibility=hidden -fdata-sections -ffunction-sections -Wl,--gc-sections -Wl,--as-needed";\
	make $(MAKEOPTS) all -C $(BUILDROOT)/eeze/compile;\
	else\
		echo "eeze is up to date.";\
	fi
	$(V)if test ! -f $(BUILDROOT)/eeze/stamps/compile -o -f $(BUILDROOT)/eeze/stamps/compile-updated; then\
		touch $(BUILDROOT)/eeze/stamps/compile;\
		echo "Compile updated, needs reinstall.";\
	fi
	$(V)echo "Success compiling eeze."

$(BUILDROOT)/eeze/stamps/install: $(BUILDROOT)/eeze/stamps/compile eeze-install
eeze-install: $(BUILDROOT)/eeze/stamps/compile
	$(V)echo "Installing eeze..."
	$(V)if test ! -f $(BUILDROOT)/eeze/stamps/install -o $(BUILDROOT)/eeze/stamps/compile -nt $(BUILDROOT)/eeze/stamps/install; then\
		rm -f $(BUILDROOT)/eeze/stamps/install;\
		echo "make $(MAKEOPTS) install -C $(BUILDROOT)/eeze/compile";\
		export PATH="$(INSTALLROOT)/bin:$${PATH}";\
	export PKG_CONFIG_PATH="$(INSTALLROOT)/lib/pkgconfig";\
	export CXXFLAGS="$${CXXFLAGS} -O2 -Wall -Wextra -Wshadow -fvisibility=hidden -fdata-sections -ffunction-sections";\
	export CFLAGS="$${CFLAGS} -O2 -Wall -Wextra -Wshadow -fvisibility=hidden -fdata-sections -ffunction-sections";\
	export LDFLAGS="$${LDFLAGS} -fvisibility=hidden -fdata-sections -ffunction-sections -Wl,--gc-sections -Wl,--as-needed";\
	make $(MAKEOPTS) install -C $(BUILDROOT)/eeze/compile;\
		mkdir -p $(BUILDROOT)/eeze/stamps;\
		touch $(BUILDROOT)/eeze/stamps/install;\
	else\
		echo "eeze did not change, not need to reinstall.";\
	fi
	$(V)echo "Success installing eeze."

$(BUILDROOT)/eeze/stamps/test: $(BUILDROOT)/eeze/stamps/compile eeze-test
eeze-test: $(BUILDROOT)/eeze/stamps/compile
	$(V)echo "Testing (make check) eeze..."
	$(V)rm -f $(BUILDROOT)/eeze/stamps/test
	export PATH="$(INSTALLROOT)/bin:$${PATH}";\
	export PKG_CONFIG_PATH="$(INSTALLROOT)/lib/pkgconfig";\
	export CXXFLAGS="$${CXXFLAGS} -O2 -Wall -Wextra -Wshadow -fvisibility=hidden -fdata-sections -ffunction-sections";\
	export CFLAGS="$${CFLAGS} -O2 -Wall -Wextra -Wshadow -fvisibility=hidden -fdata-sections -ffunction-sections";\
	export LDFLAGS="$${LDFLAGS} -fvisibility=hidden -fdata-sections -ffunction-sections -Wl,--gc-sections -Wl,--as-needed";\
	dbus-launch make $(MAKEOPTS) check -C $(BUILDROOT)/eeze/compile
	$(V)mkdir -p $(BUILDROOT)/eeze/stamps
	touch $(BUILDROOT)/eeze/stamps/test
	$(V)echo "Success testing (make check) eeze."

$(BUILDROOT)/eeze/stamps/doc: $(BUILDROOT)/eeze/stamps/compile eeze-doc
eeze-doc: $(BUILDROOT)/eeze/stamps/compile
	$(V)echo "Generating documentation (make doc) eeze..."
	$(V)rm -f $(BUILDROOT)/eeze/stamps/doc
	export PATH="$(INSTALLROOT)/bin:$${PATH}";\
	export PKG_CONFIG_PATH="$(INSTALLROOT)/lib/pkgconfig";\
	export CXXFLAGS="$${CXXFLAGS} -O2 -Wall -Wextra -Wshadow -fvisibility=hidden -fdata-sections -ffunction-sections";\
	export CFLAGS="$${CFLAGS} -O2 -Wall -Wextra -Wshadow -fvisibility=hidden -fdata-sections -ffunction-sections";\
	export LDFLAGS="$${LDFLAGS} -fvisibility=hidden -fdata-sections -ffunction-sections -Wl,--gc-sections -Wl,--as-needed";\
	make $(MAKEOPTS) doc -C $(BUILDROOT)/eeze/compile
	$(V)mkdir -p $(BUILDROOT)/eeze/stamps
	touch $(BUILDROOT)/eeze/stamps/doc
	$(V)echo "Success generating documentation (make doc) eeze."

$(BUILDROOT)/eeze/stamps/distcheck: $(BUILDROOT)/eeze/stamps/compile eeze-distcheck
eeze-distcheck: $(BUILDROOT)/eeze/stamps/compile
	$(V)echo "Checking distribution eeze..."
	$(V)rm -f $(BUILDROOT)/eeze/stamps/distcheck
	export PATH="$(INSTALLROOT)/bin:$${PATH}";\
	export PKG_CONFIG_PATH="$(INSTALLROOT)/lib/pkgconfig";\
	export CXXFLAGS="$${CXXFLAGS} -O2 -Wall -Wextra -Wshadow -fvisibility=hidden -fdata-sections -ffunction-sections";\
	export CFLAGS="$${CFLAGS} -O2 -Wall -Wextra -Wshadow -fvisibility=hidden -fdata-sections -ffunction-sections";\
	export LDFLAGS="$${LDFLAGS} -fvisibility=hidden -fdata-sections -ffunction-sections -Wl,--gc-sections -Wl,--as-needed";\
	make $(MAKEOPTS) distcheck -C $(BUILDROOT)/eeze/compile
	$(V)mkdir -p $(BUILDROOT)/eeze/stamps
	touch $(BUILDROOT)/eeze/stamps/distcheck
	$(V)echo "Success checking distribution eeze."

eeze-direct-users-compile: emotion-compile e-compile

eeze-all-users-compile: emotion-compile elementary-compile clouseau-compile e-compile terminology-compile

########################################################################
# python-evas rules
python-evas-dependencies: $(BUILDROOT)/python-evas/stamps/dependencies efl-install
$(BUILDROOT)/python-evas/stamps/dependencies: $(BUILDROOT)/efl/stamps/install
	$(V)mkdir -p $(BUILDROOT)/python-evas/stamps
	touch $(BUILDROOT)/python-evas/stamps/dependencies

python-evas-clean:
	if test -d $(BUILDROOT)/python-evas/compile; then chmod -R u+w $(BUILDROOT)/python-evas/compile; fi
	rm -fr $(BUILDROOT)/python-evas/compile
	rm -fr $(BUILDROOT)/python-evas/stamps

$(BUILDROOT)/python-evas/stamps/autogen: $(SRCROOT)/BINDINGS/python/python-evas/autogen.sh $(SRCROOT)/BINDINGS/python/python-evas/configure.ac
	$(V)echo "Running 'autogen.sh' for python-evas..."
	$(V)rm -f $(BUILDROOT)/python-evas/stamps/autogen
	cd $(SRCROOT)/BINDINGS/python/python-evas && NOCONFIGURE=1 ./autogen.sh
	$(V)mkdir -p $(BUILDROOT)/python-evas/stamps
	touch $(BUILDROOT)/python-evas/stamps/autogen
	$(V)echo "Success running 'autogen.sh' for python-evas."

$(BUILDROOT)/python-evas/stamps/configure: $(BUILDROOT)/python-evas/stamps/autogen $(BUILDROOT)/python-evas/stamps/dependencies
	$(V)echo "Configuring python-evas..."
	$(V)rm -f $(BUILDROOT)/python-evas/stamps/configure
	$(V)mkdir -p $(BUILDROOT)/python-evas/compile
	export PATH="$(INSTALLROOT)/bin:$${PATH}";\
	export PKG_CONFIG_PATH="$(INSTALLROOT)/lib/pkgconfig";\
	export CXXFLAGS="$${CXXFLAGS} -O2 -Wall -Wextra -Wshadow -fvisibility=hidden -fdata-sections -ffunction-sections";\
	export CFLAGS="$${CFLAGS} -O2 -Wall -Wextra -Wshadow -fvisibility=hidden -fdata-sections -ffunction-sections -Wno-unused-parameter -Wno-unused-but-set-variable -Wno-shadow -Wno-strict-aliasing";\
	export LDFLAGS="$${LDFLAGS} -fvisibility=hidden -fdata-sections -ffunction-sections -Wl,--gc-sections -Wl,--as-needed";\
	cd $(BUILDROOT)/python-evas/compile && \
	$(SRCROOT)/BINDINGS/python/python-evas/configure --prefix=$(INSTALLROOT) 
	$(V)mkdir -p $(BUILDROOT)/python-evas/stamps
	touch $(BUILDROOT)/python-evas/stamps/configure
	$(V)echo "Success configuring python-evas."

$(BUILDROOT)/python-evas/stamps/compile: $(BUILDROOT)/python-evas/stamps/configure python-evas-compile
python-evas-compile: $(BUILDROOT)/python-evas/stamps/configure
	$(V)echo "Compiling python-evas..."
	$(V)rm -f $(BUILDROOT)/python-evas/stamps/compile-updated
	$(V)mkdir -p $(BUILDROOT)/python-evas/stamps
	$(V)if make --dry-run $(MAKEOPTS) all -C $(BUILDROOT)/python-evas/compile 2>/dev/null | grep -e 'libtool ' >/dev/null 2>/dev/null; then\
		touch $(BUILDROOT)/python-evas/stamps/compile-updated;\
	fi
	$(V)if test -f $(BUILDROOT)/python-evas/stamps/compile-updated; then\
		echo "make $(MAKEOPTS) all -C $(BUILDROOT)/python-evas/compile";\
		export PATH="$(INSTALLROOT)/bin:$${PATH}";\
	export PKG_CONFIG_PATH="$(INSTALLROOT)/lib/pkgconfig";\
	export CXXFLAGS="$${CXXFLAGS} -O2 -Wall -Wextra -Wshadow -fvisibility=hidden -fdata-sections -ffunction-sections";\
	export CFLAGS="$${CFLAGS} -O2 -Wall -Wextra -Wshadow -fvisibility=hidden -fdata-sections -ffunction-sections -Wno-unused-parameter -Wno-unused-but-set-variable -Wno-shadow -Wno-strict-aliasing";\
	export LDFLAGS="$${LDFLAGS} -fvisibility=hidden -fdata-sections -ffunction-sections -Wl,--gc-sections -Wl,--as-needed";\
	make $(MAKEOPTS) all -C $(BUILDROOT)/python-evas/compile;\
	else\
		echo "python-evas is up to date.";\
	fi
	$(V)if test ! -f $(BUILDROOT)/python-evas/stamps/compile -o -f $(BUILDROOT)/python-evas/stamps/compile-updated; then\
		touch $(BUILDROOT)/python-evas/stamps/compile;\
		echo "Compile updated, needs reinstall.";\
	fi
	$(V)echo "Success compiling python-evas."

$(BUILDROOT)/python-evas/stamps/install: $(BUILDROOT)/python-evas/stamps/compile python-evas-install
python-evas-install: $(BUILDROOT)/python-evas/stamps/compile
	$(V)echo "Installing python-evas..."
	$(V)if test ! -f $(BUILDROOT)/python-evas/stamps/install -o $(BUILDROOT)/python-evas/stamps/compile -nt $(BUILDROOT)/python-evas/stamps/install; then\
		rm -f $(BUILDROOT)/python-evas/stamps/install;\
		echo "make $(MAKEOPTS) install -C $(BUILDROOT)/python-evas/compile";\
		export PATH="$(INSTALLROOT)/bin:$${PATH}";\
	export PKG_CONFIG_PATH="$(INSTALLROOT)/lib/pkgconfig";\
	export CXXFLAGS="$${CXXFLAGS} -O2 -Wall -Wextra -Wshadow -fvisibility=hidden -fdata-sections -ffunction-sections";\
	export CFLAGS="$${CFLAGS} -O2 -Wall -Wextra -Wshadow -fvisibility=hidden -fdata-sections -ffunction-sections -Wno-unused-parameter -Wno-unused-but-set-variable -Wno-shadow -Wno-strict-aliasing";\
	export LDFLAGS="$${LDFLAGS} -fvisibility=hidden -fdata-sections -ffunction-sections -Wl,--gc-sections -Wl,--as-needed";\
	make $(MAKEOPTS) install -C $(BUILDROOT)/python-evas/compile;\
		mkdir -p $(BUILDROOT)/python-evas/stamps;\
		touch $(BUILDROOT)/python-evas/stamps/install;\
	else\
		echo "python-evas did not change, not need to reinstall.";\
	fi
	$(V)echo "Success installing python-evas."

$(BUILDROOT)/python-evas/stamps/test: $(BUILDROOT)/python-evas/stamps/compile python-evas-test
python-evas-test: $(BUILDROOT)/python-evas/stamps/compile
	$(V)mkdir -p $(BUILDROOT)/python-evas/stamps
	touch $(BUILDROOT)/python-evas/stamps/test
	$(V)echo 'No test target defined for python-evas'

$(BUILDROOT)/python-evas/stamps/doc: $(BUILDROOT)/python-evas/stamps/compile python-evas-doc
python-evas-doc: $(BUILDROOT)/python-evas/stamps/compile
	$(V)mkdir -p $(BUILDROOT)/python-evas/stamps
	touch $(BUILDROOT)/python-evas/stamps/doc
	$(V)echo 'No doc target defined for python-evas'

$(BUILDROOT)/python-evas/stamps/distcheck: $(BUILDROOT)/python-evas/stamps/compile python-evas-distcheck
python-evas-distcheck: $(BUILDROOT)/python-evas/stamps/compile
	$(V)echo "Checking distribution python-evas..."
	$(V)rm -f $(BUILDROOT)/python-evas/stamps/distcheck
	export PATH="$(INSTALLROOT)/bin:$${PATH}";\
	export PKG_CONFIG_PATH="$(INSTALLROOT)/lib/pkgconfig";\
	export CXXFLAGS="$${CXXFLAGS} -O2 -Wall -Wextra -Wshadow -fvisibility=hidden -fdata-sections -ffunction-sections";\
	export CFLAGS="$${CFLAGS} -O2 -Wall -Wextra -Wshadow -fvisibility=hidden -fdata-sections -ffunction-sections -Wno-unused-parameter -Wno-unused-but-set-variable -Wno-shadow -Wno-strict-aliasing";\
	export LDFLAGS="$${LDFLAGS} -fvisibility=hidden -fdata-sections -ffunction-sections -Wl,--gc-sections -Wl,--as-needed";\
	make $(MAKEOPTS) distcheck -C $(BUILDROOT)/python-evas/compile
	$(V)mkdir -p $(BUILDROOT)/python-evas/stamps
	touch $(BUILDROOT)/python-evas/stamps/distcheck
	$(V)echo "Success checking distribution python-evas."

python-evas-direct-users-compile: python-e_dbus-compile python-edje-compile python-ecore-compile

python-evas-all-users-compile: python-edje-compile python-e_dbus-compile python-ecore-compile

########################################################################
# python-ecore rules
python-ecore-dependencies: $(BUILDROOT)/python-ecore/stamps/dependencies python-evas-install efl-install
$(BUILDROOT)/python-ecore/stamps/dependencies: $(BUILDROOT)/python-evas/stamps/install $(BUILDROOT)/efl/stamps/install
	$(V)mkdir -p $(BUILDROOT)/python-ecore/stamps
	touch $(BUILDROOT)/python-ecore/stamps/dependencies

python-ecore-clean:
	if test -d $(BUILDROOT)/python-ecore/compile; then chmod -R u+w $(BUILDROOT)/python-ecore/compile; fi
	rm -fr $(BUILDROOT)/python-ecore/compile
	rm -fr $(BUILDROOT)/python-ecore/stamps

$(BUILDROOT)/python-ecore/stamps/autogen: $(SRCROOT)/BINDINGS/python/python-ecore/autogen.sh $(SRCROOT)/BINDINGS/python/python-ecore/configure.ac
	$(V)echo "Running 'autogen.sh' for python-ecore..."
	$(V)rm -f $(BUILDROOT)/python-ecore/stamps/autogen
	cd $(SRCROOT)/BINDINGS/python/python-ecore && NOCONFIGURE=1 ./autogen.sh
	$(V)mkdir -p $(BUILDROOT)/python-ecore/stamps
	touch $(BUILDROOT)/python-ecore/stamps/autogen
	$(V)echo "Success running 'autogen.sh' for python-ecore."

$(BUILDROOT)/python-ecore/stamps/configure: $(BUILDROOT)/python-ecore/stamps/autogen $(BUILDROOT)/python-ecore/stamps/dependencies
	$(V)echo "Configuring python-ecore..."
	$(V)rm -f $(BUILDROOT)/python-ecore/stamps/configure
	$(V)mkdir -p $(BUILDROOT)/python-ecore/compile
	export PATH="$(INSTALLROOT)/bin:$${PATH}";\
	export PKG_CONFIG_PATH="$(INSTALLROOT)/lib/pkgconfig";\
	export CXXFLAGS="$${CXXFLAGS} -O2 -Wall -Wextra -Wshadow -fvisibility=hidden -fdata-sections -ffunction-sections";\
	export CFLAGS="$${CFLAGS} -O2 -Wall -Wextra -Wshadow -fvisibility=hidden -fdata-sections -ffunction-sections -Wno-unused-parameter -Wno-unused-but-set-variable -Wno-shadow -Wno-strict-aliasing";\
	export LDFLAGS="$${LDFLAGS} -fvisibility=hidden -fdata-sections -ffunction-sections -Wl,--gc-sections -Wl,--as-needed";\
	cd $(BUILDROOT)/python-ecore/compile && \
	$(SRCROOT)/BINDINGS/python/python-ecore/configure --prefix=$(INSTALLROOT) --enable-ecore-file \
		--enable-ecore-evas \
		--enable-ecore-x \
		--enable-ecore-imf
	$(V)mkdir -p $(BUILDROOT)/python-ecore/stamps
	touch $(BUILDROOT)/python-ecore/stamps/configure
	$(V)echo "Success configuring python-ecore."

$(BUILDROOT)/python-ecore/stamps/compile: $(BUILDROOT)/python-ecore/stamps/configure python-ecore-compile
python-ecore-compile: $(BUILDROOT)/python-ecore/stamps/configure
	$(V)echo "Compiling python-ecore..."
	$(V)rm -f $(BUILDROOT)/python-ecore/stamps/compile-updated
	$(V)mkdir -p $(BUILDROOT)/python-ecore/stamps
	$(V)if make --dry-run $(MAKEOPTS) all -C $(BUILDROOT)/python-ecore/compile 2>/dev/null | grep -e 'libtool ' >/dev/null 2>/dev/null; then\
		touch $(BUILDROOT)/python-ecore/stamps/compile-updated;\
	fi
	$(V)if test -f $(BUILDROOT)/python-ecore/stamps/compile-updated; then\
		echo "make $(MAKEOPTS) all -C $(BUILDROOT)/python-ecore/compile";\
		export PATH="$(INSTALLROOT)/bin:$${PATH}";\
	export PKG_CONFIG_PATH="$(INSTALLROOT)/lib/pkgconfig";\
	export CXXFLAGS="$${CXXFLAGS} -O2 -Wall -Wextra -Wshadow -fvisibility=hidden -fdata-sections -ffunction-sections";\
	export CFLAGS="$${CFLAGS} -O2 -Wall -Wextra -Wshadow -fvisibility=hidden -fdata-sections -ffunction-sections -Wno-unused-parameter -Wno-unused-but-set-variable -Wno-shadow -Wno-strict-aliasing";\
	export LDFLAGS="$${LDFLAGS} -fvisibility=hidden -fdata-sections -ffunction-sections -Wl,--gc-sections -Wl,--as-needed";\
	make $(MAKEOPTS) all -C $(BUILDROOT)/python-ecore/compile;\
	else\
		echo "python-ecore is up to date.";\
	fi
	$(V)if test ! -f $(BUILDROOT)/python-ecore/stamps/compile -o -f $(BUILDROOT)/python-ecore/stamps/compile-updated; then\
		touch $(BUILDROOT)/python-ecore/stamps/compile;\
		echo "Compile updated, needs reinstall.";\
	fi
	$(V)echo "Success compiling python-ecore."

$(BUILDROOT)/python-ecore/stamps/install: $(BUILDROOT)/python-ecore/stamps/compile python-ecore-install
python-ecore-install: $(BUILDROOT)/python-ecore/stamps/compile
	$(V)echo "Installing python-ecore..."
	$(V)if test ! -f $(BUILDROOT)/python-ecore/stamps/install -o $(BUILDROOT)/python-ecore/stamps/compile -nt $(BUILDROOT)/python-ecore/stamps/install; then\
		rm -f $(BUILDROOT)/python-ecore/stamps/install;\
		echo "make $(MAKEOPTS) install -C $(BUILDROOT)/python-ecore/compile";\
		export PATH="$(INSTALLROOT)/bin:$${PATH}";\
	export PKG_CONFIG_PATH="$(INSTALLROOT)/lib/pkgconfig";\
	export CXXFLAGS="$${CXXFLAGS} -O2 -Wall -Wextra -Wshadow -fvisibility=hidden -fdata-sections -ffunction-sections";\
	export CFLAGS="$${CFLAGS} -O2 -Wall -Wextra -Wshadow -fvisibility=hidden -fdata-sections -ffunction-sections -Wno-unused-parameter -Wno-unused-but-set-variable -Wno-shadow -Wno-strict-aliasing";\
	export LDFLAGS="$${LDFLAGS} -fvisibility=hidden -fdata-sections -ffunction-sections -Wl,--gc-sections -Wl,--as-needed";\
	make $(MAKEOPTS) install -C $(BUILDROOT)/python-ecore/compile;\
		mkdir -p $(BUILDROOT)/python-ecore/stamps;\
		touch $(BUILDROOT)/python-ecore/stamps/install;\
	else\
		echo "python-ecore did not change, not need to reinstall.";\
	fi
	$(V)echo "Success installing python-ecore."

$(BUILDROOT)/python-ecore/stamps/test: $(BUILDROOT)/python-ecore/stamps/compile python-ecore-test
python-ecore-test: $(BUILDROOT)/python-ecore/stamps/compile
	$(V)mkdir -p $(BUILDROOT)/python-ecore/stamps
	touch $(BUILDROOT)/python-ecore/stamps/test
	$(V)echo 'No test target defined for python-ecore'

$(BUILDROOT)/python-ecore/stamps/doc: $(BUILDROOT)/python-ecore/stamps/compile python-ecore-doc
python-ecore-doc: $(BUILDROOT)/python-ecore/stamps/compile
	$(V)mkdir -p $(BUILDROOT)/python-ecore/stamps
	touch $(BUILDROOT)/python-ecore/stamps/doc
	$(V)echo 'No doc target defined for python-ecore'

$(BUILDROOT)/python-ecore/stamps/distcheck: $(BUILDROOT)/python-ecore/stamps/compile python-ecore-distcheck
python-ecore-distcheck: $(BUILDROOT)/python-ecore/stamps/compile
	$(V)echo "Checking distribution python-ecore..."
	$(V)rm -f $(BUILDROOT)/python-ecore/stamps/distcheck
	export PATH="$(INSTALLROOT)/bin:$${PATH}";\
	export PKG_CONFIG_PATH="$(INSTALLROOT)/lib/pkgconfig";\
	export CXXFLAGS="$${CXXFLAGS} -O2 -Wall -Wextra -Wshadow -fvisibility=hidden -fdata-sections -ffunction-sections";\
	export CFLAGS="$${CFLAGS} -O2 -Wall -Wextra -Wshadow -fvisibility=hidden -fdata-sections -ffunction-sections -Wno-unused-parameter -Wno-unused-but-set-variable -Wno-shadow -Wno-strict-aliasing";\
	export LDFLAGS="$${LDFLAGS} -fvisibility=hidden -fdata-sections -ffunction-sections -Wl,--gc-sections -Wl,--as-needed";\
	make $(MAKEOPTS) distcheck -C $(BUILDROOT)/python-ecore/compile
	$(V)mkdir -p $(BUILDROOT)/python-ecore/stamps
	touch $(BUILDROOT)/python-ecore/stamps/distcheck
	$(V)echo "Success checking distribution python-ecore."

python-ecore-direct-users-compile:

python-ecore-all-users-compile:

########################################################################
# python-e_dbus rules
python-e_dbus-dependencies: $(BUILDROOT)/python-e_dbus/stamps/dependencies e_dbus-install python-evas-install
$(BUILDROOT)/python-e_dbus/stamps/dependencies: $(BUILDROOT)/e_dbus/stamps/install $(BUILDROOT)/python-evas/stamps/install
	$(V)mkdir -p $(BUILDROOT)/python-e_dbus/stamps
	touch $(BUILDROOT)/python-e_dbus/stamps/dependencies

python-e_dbus-clean:
	if test -d $(BUILDROOT)/python-e_dbus/compile; then chmod -R u+w $(BUILDROOT)/python-e_dbus/compile; fi
	rm -fr $(BUILDROOT)/python-e_dbus/compile
	rm -fr $(BUILDROOT)/python-e_dbus/stamps

$(BUILDROOT)/python-e_dbus/stamps/autogen: $(SRCROOT)/BINDINGS/python/python-e_dbus/autogen.sh $(SRCROOT)/BINDINGS/python/python-e_dbus/configure.ac
	$(V)echo "Running 'autogen.sh' for python-e_dbus..."
	$(V)rm -f $(BUILDROOT)/python-e_dbus/stamps/autogen
	cd $(SRCROOT)/BINDINGS/python/python-e_dbus && NOCONFIGURE=1 ./autogen.sh
	$(V)mkdir -p $(BUILDROOT)/python-e_dbus/stamps
	touch $(BUILDROOT)/python-e_dbus/stamps/autogen
	$(V)echo "Success running 'autogen.sh' for python-e_dbus."

$(BUILDROOT)/python-e_dbus/stamps/configure: $(BUILDROOT)/python-e_dbus/stamps/autogen $(BUILDROOT)/python-e_dbus/stamps/dependencies
	$(V)echo "Configuring python-e_dbus..."
	$(V)rm -f $(BUILDROOT)/python-e_dbus/stamps/configure
	$(V)mkdir -p $(BUILDROOT)/python-e_dbus/compile
	export PATH="$(INSTALLROOT)/bin:$${PATH}";\
	export PKG_CONFIG_PATH="$(INSTALLROOT)/lib/pkgconfig";\
	export CXXFLAGS="$${CXXFLAGS} -O2 -Wall -Wextra -Wshadow -fvisibility=hidden -fdata-sections -ffunction-sections";\
	export CFLAGS="$${CFLAGS} -O2 -Wall -Wextra -Wshadow -fvisibility=hidden -fdata-sections -ffunction-sections";\
	export LDFLAGS="$${LDFLAGS} -fvisibility=hidden -fdata-sections -ffunction-sections -Wl,--gc-sections -Wl,--as-needed";\
	cd $(BUILDROOT)/python-e_dbus/compile && \
	$(SRCROOT)/BINDINGS/python/python-e_dbus/configure --prefix=$(INSTALLROOT) 
	$(V)mkdir -p $(BUILDROOT)/python-e_dbus/stamps
	touch $(BUILDROOT)/python-e_dbus/stamps/configure
	$(V)echo "Success configuring python-e_dbus."

$(BUILDROOT)/python-e_dbus/stamps/compile: $(BUILDROOT)/python-e_dbus/stamps/configure python-e_dbus-compile
python-e_dbus-compile: $(BUILDROOT)/python-e_dbus/stamps/configure
	$(V)echo "Compiling python-e_dbus..."
	$(V)rm -f $(BUILDROOT)/python-e_dbus/stamps/compile-updated
	$(V)mkdir -p $(BUILDROOT)/python-e_dbus/stamps
	$(V)if make --dry-run $(MAKEOPTS) all -C $(BUILDROOT)/python-e_dbus/compile 2>/dev/null | grep -e 'libtool ' >/dev/null 2>/dev/null; then\
		touch $(BUILDROOT)/python-e_dbus/stamps/compile-updated;\
	fi
	$(V)if test -f $(BUILDROOT)/python-e_dbus/stamps/compile-updated; then\
		echo "make $(MAKEOPTS) all -C $(BUILDROOT)/python-e_dbus/compile";\
		export PATH="$(INSTALLROOT)/bin:$${PATH}";\
	export PKG_CONFIG_PATH="$(INSTALLROOT)/lib/pkgconfig";\
	export CXXFLAGS="$${CXXFLAGS} -O2 -Wall -Wextra -Wshadow -fvisibility=hidden -fdata-sections -ffunction-sections";\
	export CFLAGS="$${CFLAGS} -O2 -Wall -Wextra -Wshadow -fvisibility=hidden -fdata-sections -ffunction-sections";\
	export LDFLAGS="$${LDFLAGS} -fvisibility=hidden -fdata-sections -ffunction-sections -Wl,--gc-sections -Wl,--as-needed";\
	make $(MAKEOPTS) all -C $(BUILDROOT)/python-e_dbus/compile;\
	else\
		echo "python-e_dbus is up to date.";\
	fi
	$(V)if test ! -f $(BUILDROOT)/python-e_dbus/stamps/compile -o -f $(BUILDROOT)/python-e_dbus/stamps/compile-updated; then\
		touch $(BUILDROOT)/python-e_dbus/stamps/compile;\
		echo "Compile updated, needs reinstall.";\
	fi
	$(V)echo "Success compiling python-e_dbus."

$(BUILDROOT)/python-e_dbus/stamps/install: $(BUILDROOT)/python-e_dbus/stamps/compile python-e_dbus-install
python-e_dbus-install: $(BUILDROOT)/python-e_dbus/stamps/compile
	$(V)echo "Installing python-e_dbus..."
	$(V)if test ! -f $(BUILDROOT)/python-e_dbus/stamps/install -o $(BUILDROOT)/python-e_dbus/stamps/compile -nt $(BUILDROOT)/python-e_dbus/stamps/install; then\
		rm -f $(BUILDROOT)/python-e_dbus/stamps/install;\
		echo "make $(MAKEOPTS) install -C $(BUILDROOT)/python-e_dbus/compile";\
		export PATH="$(INSTALLROOT)/bin:$${PATH}";\
	export PKG_CONFIG_PATH="$(INSTALLROOT)/lib/pkgconfig";\
	export CXXFLAGS="$${CXXFLAGS} -O2 -Wall -Wextra -Wshadow -fvisibility=hidden -fdata-sections -ffunction-sections";\
	export CFLAGS="$${CFLAGS} -O2 -Wall -Wextra -Wshadow -fvisibility=hidden -fdata-sections -ffunction-sections";\
	export LDFLAGS="$${LDFLAGS} -fvisibility=hidden -fdata-sections -ffunction-sections -Wl,--gc-sections -Wl,--as-needed";\
	make $(MAKEOPTS) install -C $(BUILDROOT)/python-e_dbus/compile;\
		mkdir -p $(BUILDROOT)/python-e_dbus/stamps;\
		touch $(BUILDROOT)/python-e_dbus/stamps/install;\
	else\
		echo "python-e_dbus did not change, not need to reinstall.";\
	fi
	$(V)echo "Success installing python-e_dbus."

$(BUILDROOT)/python-e_dbus/stamps/test: $(BUILDROOT)/python-e_dbus/stamps/compile python-e_dbus-test
python-e_dbus-test: $(BUILDROOT)/python-e_dbus/stamps/compile
	$(V)mkdir -p $(BUILDROOT)/python-e_dbus/stamps
	touch $(BUILDROOT)/python-e_dbus/stamps/test
	$(V)echo 'No test target defined for python-e_dbus'

$(BUILDROOT)/python-e_dbus/stamps/doc: $(BUILDROOT)/python-e_dbus/stamps/compile python-e_dbus-doc
python-e_dbus-doc: $(BUILDROOT)/python-e_dbus/stamps/compile
	$(V)mkdir -p $(BUILDROOT)/python-e_dbus/stamps
	touch $(BUILDROOT)/python-e_dbus/stamps/doc
	$(V)echo 'No doc target defined for python-e_dbus'

$(BUILDROOT)/python-e_dbus/stamps/distcheck: $(BUILDROOT)/python-e_dbus/stamps/compile python-e_dbus-distcheck
python-e_dbus-distcheck: $(BUILDROOT)/python-e_dbus/stamps/compile
	$(V)echo "Checking distribution python-e_dbus..."
	$(V)rm -f $(BUILDROOT)/python-e_dbus/stamps/distcheck
	export PATH="$(INSTALLROOT)/bin:$${PATH}";\
	export PKG_CONFIG_PATH="$(INSTALLROOT)/lib/pkgconfig";\
	export CXXFLAGS="$${CXXFLAGS} -O2 -Wall -Wextra -Wshadow -fvisibility=hidden -fdata-sections -ffunction-sections";\
	export CFLAGS="$${CFLAGS} -O2 -Wall -Wextra -Wshadow -fvisibility=hidden -fdata-sections -ffunction-sections";\
	export LDFLAGS="$${LDFLAGS} -fvisibility=hidden -fdata-sections -ffunction-sections -Wl,--gc-sections -Wl,--as-needed";\
	make $(MAKEOPTS) distcheck -C $(BUILDROOT)/python-e_dbus/compile
	$(V)mkdir -p $(BUILDROOT)/python-e_dbus/stamps
	touch $(BUILDROOT)/python-e_dbus/stamps/distcheck
	$(V)echo "Success checking distribution python-e_dbus."

python-e_dbus-direct-users-compile:

python-e_dbus-all-users-compile:

########################################################################
# efx rules
efx-dependencies: $(BUILDROOT)/efx/stamps/dependencies efl-install
$(BUILDROOT)/efx/stamps/dependencies: $(BUILDROOT)/efl/stamps/install
	$(V)mkdir -p $(BUILDROOT)/efx/stamps
	touch $(BUILDROOT)/efx/stamps/dependencies

efx-clean:
	if test -d $(BUILDROOT)/efx/compile; then chmod -R u+w $(BUILDROOT)/efx/compile; fi
	rm -fr $(BUILDROOT)/efx/compile
	rm -fr $(BUILDROOT)/efx/stamps

$(BUILDROOT)/efx/stamps/autogen: $(SRCROOT)/efx/autogen.sh $(SRCROOT)/efx/configure.ac
	$(V)echo "Running 'autogen.sh' for efx..."
	$(V)rm -f $(BUILDROOT)/efx/stamps/autogen
	cd $(SRCROOT)/efx && NOCONFIGURE=1 ./autogen.sh
	$(V)mkdir -p $(BUILDROOT)/efx/stamps
	touch $(BUILDROOT)/efx/stamps/autogen
	$(V)echo "Success running 'autogen.sh' for efx."

$(BUILDROOT)/efx/stamps/configure: $(BUILDROOT)/efx/stamps/autogen $(BUILDROOT)/efx/stamps/dependencies
	$(V)echo "Configuring efx..."
	$(V)rm -f $(BUILDROOT)/efx/stamps/configure
	$(V)mkdir -p $(BUILDROOT)/efx/compile
	export PATH="$(INSTALLROOT)/bin:$${PATH}";\
	export PKG_CONFIG_PATH="$(INSTALLROOT)/lib/pkgconfig";\
	export CXXFLAGS="$${CXXFLAGS} -O2 -Wall -Wextra -Wshadow -fvisibility=hidden -fdata-sections -ffunction-sections";\
	export CFLAGS="$${CFLAGS} -O2 -Wall -Wextra -Wshadow -fvisibility=hidden -fdata-sections -ffunction-sections";\
	export LDFLAGS="$${LDFLAGS} -fvisibility=hidden -fdata-sections -ffunction-sections -Wl,--gc-sections -Wl,--as-needed";\
	cd $(BUILDROOT)/efx/compile && \
	$(SRCROOT)/efx/configure --prefix=$(INSTALLROOT) 
	$(V)mkdir -p $(BUILDROOT)/efx/stamps
	touch $(BUILDROOT)/efx/stamps/configure
	$(V)echo "Success configuring efx."

$(BUILDROOT)/efx/stamps/compile: $(BUILDROOT)/efx/stamps/configure efx-compile
efx-compile: $(BUILDROOT)/efx/stamps/configure
	$(V)echo "Compiling efx..."
	$(V)rm -f $(BUILDROOT)/efx/stamps/compile-updated
	$(V)mkdir -p $(BUILDROOT)/efx/stamps
	$(V)if make --dry-run $(MAKEOPTS) all -C $(BUILDROOT)/efx/compile 2>/dev/null | grep -e 'libtool ' >/dev/null 2>/dev/null; then\
		touch $(BUILDROOT)/efx/stamps/compile-updated;\
	fi
	$(V)if test -f $(BUILDROOT)/efx/stamps/compile-updated; then\
		echo "make $(MAKEOPTS) all -C $(BUILDROOT)/efx/compile";\
		export PATH="$(INSTALLROOT)/bin:$${PATH}";\
	export PKG_CONFIG_PATH="$(INSTALLROOT)/lib/pkgconfig";\
	export CXXFLAGS="$${CXXFLAGS} -O2 -Wall -Wextra -Wshadow -fvisibility=hidden -fdata-sections -ffunction-sections";\
	export CFLAGS="$${CFLAGS} -O2 -Wall -Wextra -Wshadow -fvisibility=hidden -fdata-sections -ffunction-sections";\
	export LDFLAGS="$${LDFLAGS} -fvisibility=hidden -fdata-sections -ffunction-sections -Wl,--gc-sections -Wl,--as-needed";\
	make $(MAKEOPTS) all -C $(BUILDROOT)/efx/compile;\
	else\
		echo "efx is up to date.";\
	fi
	$(V)if test ! -f $(BUILDROOT)/efx/stamps/compile -o -f $(BUILDROOT)/efx/stamps/compile-updated; then\
		touch $(BUILDROOT)/efx/stamps/compile;\
		echo "Compile updated, needs reinstall.";\
	fi
	$(V)echo "Success compiling efx."

$(BUILDROOT)/efx/stamps/install: $(BUILDROOT)/efx/stamps/compile efx-install
efx-install: $(BUILDROOT)/efx/stamps/compile
	$(V)echo "Installing efx..."
	$(V)if test ! -f $(BUILDROOT)/efx/stamps/install -o $(BUILDROOT)/efx/stamps/compile -nt $(BUILDROOT)/efx/stamps/install; then\
		rm -f $(BUILDROOT)/efx/stamps/install;\
		echo "make $(MAKEOPTS) install -C $(BUILDROOT)/efx/compile";\
		export PATH="$(INSTALLROOT)/bin:$${PATH}";\
	export PKG_CONFIG_PATH="$(INSTALLROOT)/lib/pkgconfig";\
	export CXXFLAGS="$${CXXFLAGS} -O2 -Wall -Wextra -Wshadow -fvisibility=hidden -fdata-sections -ffunction-sections";\
	export CFLAGS="$${CFLAGS} -O2 -Wall -Wextra -Wshadow -fvisibility=hidden -fdata-sections -ffunction-sections";\
	export LDFLAGS="$${LDFLAGS} -fvisibility=hidden -fdata-sections -ffunction-sections -Wl,--gc-sections -Wl,--as-needed";\
	make $(MAKEOPTS) install -C $(BUILDROOT)/efx/compile;\
		mkdir -p $(BUILDROOT)/efx/stamps;\
		touch $(BUILDROOT)/efx/stamps/install;\
	else\
		echo "efx did not change, not need to reinstall.";\
	fi
	$(V)echo "Success installing efx."

$(BUILDROOT)/efx/stamps/test: $(BUILDROOT)/efx/stamps/compile efx-test
efx-test: $(BUILDROOT)/efx/stamps/compile
	$(V)mkdir -p $(BUILDROOT)/efx/stamps
	touch $(BUILDROOT)/efx/stamps/test
	$(V)echo 'No test target defined for efx'

$(BUILDROOT)/efx/stamps/doc: $(BUILDROOT)/efx/stamps/compile efx-doc
efx-doc: $(BUILDROOT)/efx/stamps/compile
	$(V)echo "Generating documentation (make doc) efx..."
	$(V)rm -f $(BUILDROOT)/efx/stamps/doc
	export PATH="$(INSTALLROOT)/bin:$${PATH}";\
	export PKG_CONFIG_PATH="$(INSTALLROOT)/lib/pkgconfig";\
	export CXXFLAGS="$${CXXFLAGS} -O2 -Wall -Wextra -Wshadow -fvisibility=hidden -fdata-sections -ffunction-sections";\
	export CFLAGS="$${CFLAGS} -O2 -Wall -Wextra -Wshadow -fvisibility=hidden -fdata-sections -ffunction-sections";\
	export LDFLAGS="$${LDFLAGS} -fvisibility=hidden -fdata-sections -ffunction-sections -Wl,--gc-sections -Wl,--as-needed";\
	make $(MAKEOPTS) doc -C $(BUILDROOT)/efx/compile
	$(V)mkdir -p $(BUILDROOT)/efx/stamps
	touch $(BUILDROOT)/efx/stamps/doc
	$(V)echo "Success generating documentation (make doc) efx."

$(BUILDROOT)/efx/stamps/distcheck: $(BUILDROOT)/efx/stamps/compile efx-distcheck
efx-distcheck: $(BUILDROOT)/efx/stamps/compile
	$(V)echo "Checking distribution efx..."
	$(V)rm -f $(BUILDROOT)/efx/stamps/distcheck
	export PATH="$(INSTALLROOT)/bin:$${PATH}";\
	export PKG_CONFIG_PATH="$(INSTALLROOT)/lib/pkgconfig";\
	export CXXFLAGS="$${CXXFLAGS} -O2 -Wall -Wextra -Wshadow -fvisibility=hidden -fdata-sections -ffunction-sections";\
	export CFLAGS="$${CFLAGS} -O2 -Wall -Wextra -Wshadow -fvisibility=hidden -fdata-sections -ffunction-sections";\
	export LDFLAGS="$${LDFLAGS} -fvisibility=hidden -fdata-sections -ffunction-sections -Wl,--gc-sections -Wl,--as-needed";\
	make $(MAKEOPTS) distcheck -C $(BUILDROOT)/efx/compile
	$(V)mkdir -p $(BUILDROOT)/efx/stamps
	touch $(BUILDROOT)/efx/stamps/distcheck
	$(V)echo "Success checking distribution efx."

efx-direct-users-compile:

efx-all-users-compile:

########################################################################
# edbus rules
edbus-dependencies: $(BUILDROOT)/edbus/stamps/dependencies efl-install
$(BUILDROOT)/edbus/stamps/dependencies: $(BUILDROOT)/efl/stamps/install
	$(V)mkdir -p $(BUILDROOT)/edbus/stamps
	touch $(BUILDROOT)/edbus/stamps/dependencies

edbus-clean:
	if test -d $(BUILDROOT)/edbus/compile; then chmod -R u+w $(BUILDROOT)/edbus/compile; fi
	rm -fr $(BUILDROOT)/edbus/compile
	rm -fr $(BUILDROOT)/edbus/stamps

$(BUILDROOT)/edbus/stamps/autogen: $(SRCROOT)/edbus/autogen.sh $(SRCROOT)/edbus/configure.ac
	$(V)echo "Running 'autogen.sh' for edbus..."
	$(V)rm -f $(BUILDROOT)/edbus/stamps/autogen
	cd $(SRCROOT)/edbus && NOCONFIGURE=1 ./autogen.sh
	$(V)mkdir -p $(BUILDROOT)/edbus/stamps
	touch $(BUILDROOT)/edbus/stamps/autogen
	$(V)echo "Success running 'autogen.sh' for edbus."

$(BUILDROOT)/edbus/stamps/configure: $(BUILDROOT)/edbus/stamps/autogen $(BUILDROOT)/edbus/stamps/dependencies
	$(V)echo "Configuring edbus..."
	$(V)rm -f $(BUILDROOT)/edbus/stamps/configure
	$(V)mkdir -p $(BUILDROOT)/edbus/compile
	export PATH="$(INSTALLROOT)/bin:$${PATH}";\
	export PKG_CONFIG_PATH="$(INSTALLROOT)/lib/pkgconfig";\
	export CXXFLAGS="$${CXXFLAGS} -O2 -Wall -Wextra -Wshadow -fvisibility=hidden -fdata-sections -ffunction-sections";\
	export CFLAGS="$${CFLAGS} -O2 -Wall -Wextra -Wshadow -fvisibility=hidden -fdata-sections -ffunction-sections";\
	export LDFLAGS="$${LDFLAGS} -fvisibility=hidden -fdata-sections -ffunction-sections -Wl,--gc-sections -Wl,--as-needed";\
	cd $(BUILDROOT)/edbus/compile && \
	$(SRCROOT)/edbus/configure --prefix=$(INSTALLROOT) 
	$(V)mkdir -p $(BUILDROOT)/edbus/stamps
	touch $(BUILDROOT)/edbus/stamps/configure
	$(V)echo "Success configuring edbus."

$(BUILDROOT)/edbus/stamps/compile: $(BUILDROOT)/edbus/stamps/configure edbus-compile
edbus-compile: $(BUILDROOT)/edbus/stamps/configure
	$(V)echo "Compiling edbus..."
	$(V)rm -f $(BUILDROOT)/edbus/stamps/compile-updated
	$(V)mkdir -p $(BUILDROOT)/edbus/stamps
	$(V)if make --dry-run $(MAKEOPTS) all -C $(BUILDROOT)/edbus/compile 2>/dev/null | grep -e 'libtool ' >/dev/null 2>/dev/null; then\
		touch $(BUILDROOT)/edbus/stamps/compile-updated;\
	fi
	$(V)if test -f $(BUILDROOT)/edbus/stamps/compile-updated; then\
		echo "make $(MAKEOPTS) all -C $(BUILDROOT)/edbus/compile";\
		export PATH="$(INSTALLROOT)/bin:$${PATH}";\
	export PKG_CONFIG_PATH="$(INSTALLROOT)/lib/pkgconfig";\
	export CXXFLAGS="$${CXXFLAGS} -O2 -Wall -Wextra -Wshadow -fvisibility=hidden -fdata-sections -ffunction-sections";\
	export CFLAGS="$${CFLAGS} -O2 -Wall -Wextra -Wshadow -fvisibility=hidden -fdata-sections -ffunction-sections";\
	export LDFLAGS="$${LDFLAGS} -fvisibility=hidden -fdata-sections -ffunction-sections -Wl,--gc-sections -Wl,--as-needed";\
	make $(MAKEOPTS) all -C $(BUILDROOT)/edbus/compile;\
	else\
		echo "edbus is up to date.";\
	fi
	$(V)if test ! -f $(BUILDROOT)/edbus/stamps/compile -o -f $(BUILDROOT)/edbus/stamps/compile-updated; then\
		touch $(BUILDROOT)/edbus/stamps/compile;\
		echo "Compile updated, needs reinstall.";\
	fi
	$(V)echo "Success compiling edbus."

$(BUILDROOT)/edbus/stamps/install: $(BUILDROOT)/edbus/stamps/compile edbus-install
edbus-install: $(BUILDROOT)/edbus/stamps/compile
	$(V)echo "Installing edbus..."
	$(V)if test ! -f $(BUILDROOT)/edbus/stamps/install -o $(BUILDROOT)/edbus/stamps/compile -nt $(BUILDROOT)/edbus/stamps/install; then\
		rm -f $(BUILDROOT)/edbus/stamps/install;\
		echo "make $(MAKEOPTS) install -C $(BUILDROOT)/edbus/compile";\
		export PATH="$(INSTALLROOT)/bin:$${PATH}";\
	export PKG_CONFIG_PATH="$(INSTALLROOT)/lib/pkgconfig";\
	export CXXFLAGS="$${CXXFLAGS} -O2 -Wall -Wextra -Wshadow -fvisibility=hidden -fdata-sections -ffunction-sections";\
	export CFLAGS="$${CFLAGS} -O2 -Wall -Wextra -Wshadow -fvisibility=hidden -fdata-sections -ffunction-sections";\
	export LDFLAGS="$${LDFLAGS} -fvisibility=hidden -fdata-sections -ffunction-sections -Wl,--gc-sections -Wl,--as-needed";\
	make $(MAKEOPTS) install -C $(BUILDROOT)/edbus/compile;\
		mkdir -p $(BUILDROOT)/edbus/stamps;\
		touch $(BUILDROOT)/edbus/stamps/install;\
	else\
		echo "edbus did not change, not need to reinstall.";\
	fi
	$(V)echo "Success installing edbus."

$(BUILDROOT)/edbus/stamps/test: $(BUILDROOT)/edbus/stamps/compile edbus-test
edbus-test: $(BUILDROOT)/edbus/stamps/compile
	$(V)mkdir -p $(BUILDROOT)/edbus/stamps
	touch $(BUILDROOT)/edbus/stamps/test
	$(V)echo 'No test target defined for edbus'

$(BUILDROOT)/edbus/stamps/doc: $(BUILDROOT)/edbus/stamps/compile edbus-doc
edbus-doc: $(BUILDROOT)/edbus/stamps/compile
	$(V)echo "Generating documentation (make doc) edbus..."
	$(V)rm -f $(BUILDROOT)/edbus/stamps/doc
	export PATH="$(INSTALLROOT)/bin:$${PATH}";\
	export PKG_CONFIG_PATH="$(INSTALLROOT)/lib/pkgconfig";\
	export CXXFLAGS="$${CXXFLAGS} -O2 -Wall -Wextra -Wshadow -fvisibility=hidden -fdata-sections -ffunction-sections";\
	export CFLAGS="$${CFLAGS} -O2 -Wall -Wextra -Wshadow -fvisibility=hidden -fdata-sections -ffunction-sections";\
	export LDFLAGS="$${LDFLAGS} -fvisibility=hidden -fdata-sections -ffunction-sections -Wl,--gc-sections -Wl,--as-needed";\
	make $(MAKEOPTS) doc -C $(BUILDROOT)/edbus/compile
	$(V)mkdir -p $(BUILDROOT)/edbus/stamps
	touch $(BUILDROOT)/edbus/stamps/doc
	$(V)echo "Success generating documentation (make doc) edbus."

$(BUILDROOT)/edbus/stamps/distcheck: $(BUILDROOT)/edbus/stamps/compile edbus-distcheck
edbus-distcheck: $(BUILDROOT)/edbus/stamps/compile
	$(V)echo "Checking distribution edbus..."
	$(V)rm -f $(BUILDROOT)/edbus/stamps/distcheck
	export PATH="$(INSTALLROOT)/bin:$${PATH}";\
	export PKG_CONFIG_PATH="$(INSTALLROOT)/lib/pkgconfig";\
	export CXXFLAGS="$${CXXFLAGS} -O2 -Wall -Wextra -Wshadow -fvisibility=hidden -fdata-sections -ffunction-sections";\
	export CFLAGS="$${CFLAGS} -O2 -Wall -Wextra -Wshadow -fvisibility=hidden -fdata-sections -ffunction-sections";\
	export LDFLAGS="$${LDFLAGS} -fvisibility=hidden -fdata-sections -ffunction-sections -Wl,--gc-sections -Wl,--as-needed";\
	make $(MAKEOPTS) distcheck -C $(BUILDROOT)/edbus/compile
	$(V)mkdir -p $(BUILDROOT)/edbus/stamps
	touch $(BUILDROOT)/edbus/stamps/distcheck
	$(V)echo "Success checking distribution edbus."

edbus-direct-users-compile: efreet-compile

edbus-all-users-compile: elementary-compile clouseau-compile e-compile terminology-compile efreet-compile

########################################################################
# efreet rules
efreet-dependencies: $(BUILDROOT)/efreet/stamps/dependencies edbus-install efl-install
$(BUILDROOT)/efreet/stamps/dependencies: $(BUILDROOT)/edbus/stamps/install $(BUILDROOT)/efl/stamps/install
	$(V)mkdir -p $(BUILDROOT)/efreet/stamps
	touch $(BUILDROOT)/efreet/stamps/dependencies

efreet-clean:
	if test -d $(BUILDROOT)/efreet/compile; then chmod -R u+w $(BUILDROOT)/efreet/compile; fi
	rm -fr $(BUILDROOT)/efreet/compile
	rm -fr $(BUILDROOT)/efreet/stamps

$(BUILDROOT)/efreet/stamps/autogen: $(SRCROOT)/efreet/autogen.sh $(SRCROOT)/efreet/configure.ac
	$(V)echo "Running 'autogen.sh' for efreet..."
	$(V)rm -f $(BUILDROOT)/efreet/stamps/autogen
	cd $(SRCROOT)/efreet && NOCONFIGURE=1 ./autogen.sh
	$(V)mkdir -p $(BUILDROOT)/efreet/stamps
	touch $(BUILDROOT)/efreet/stamps/autogen
	$(V)echo "Success running 'autogen.sh' for efreet."

$(BUILDROOT)/efreet/stamps/configure: $(BUILDROOT)/efreet/stamps/autogen $(BUILDROOT)/efreet/stamps/dependencies
	$(V)echo "Configuring efreet..."
	$(V)rm -f $(BUILDROOT)/efreet/stamps/configure
	$(V)mkdir -p $(BUILDROOT)/efreet/compile
	export PATH="$(INSTALLROOT)/bin:$${PATH}";\
	export PKG_CONFIG_PATH="$(INSTALLROOT)/lib/pkgconfig";\
	export CXXFLAGS="$${CXXFLAGS} -O2 -Wall -Wextra -Wshadow -fvisibility=hidden -fdata-sections -ffunction-sections";\
	export CFLAGS="$${CFLAGS} -O2 -Wall -Wextra -Wshadow -fvisibility=hidden -fdata-sections -ffunction-sections";\
	export LDFLAGS="$${LDFLAGS} -fvisibility=hidden -fdata-sections -ffunction-sections -Wl,--gc-sections -Wl,--as-needed";\
	cd $(BUILDROOT)/efreet/compile && \
	$(SRCROOT)/efreet/configure --prefix=$(INSTALLROOT) --enable-tests \
		--enable-doc \
		--enable-coverage
	$(V)mkdir -p $(BUILDROOT)/efreet/stamps
	touch $(BUILDROOT)/efreet/stamps/configure
	$(V)echo "Success configuring efreet."

$(BUILDROOT)/efreet/stamps/compile: $(BUILDROOT)/efreet/stamps/configure efreet-compile
efreet-compile: $(BUILDROOT)/efreet/stamps/configure
	$(V)echo "Compiling efreet..."
	$(V)rm -f $(BUILDROOT)/efreet/stamps/compile-updated
	$(V)mkdir -p $(BUILDROOT)/efreet/stamps
	$(V)if make --dry-run $(MAKEOPTS) all -C $(BUILDROOT)/efreet/compile 2>/dev/null | grep -e 'libtool ' >/dev/null 2>/dev/null; then\
		touch $(BUILDROOT)/efreet/stamps/compile-updated;\
	fi
	$(V)if test -f $(BUILDROOT)/efreet/stamps/compile-updated; then\
		echo "make $(MAKEOPTS) all -C $(BUILDROOT)/efreet/compile";\
		export PATH="$(INSTALLROOT)/bin:$${PATH}";\
	export PKG_CONFIG_PATH="$(INSTALLROOT)/lib/pkgconfig";\
	export CXXFLAGS="$${CXXFLAGS} -O2 -Wall -Wextra -Wshadow -fvisibility=hidden -fdata-sections -ffunction-sections";\
	export CFLAGS="$${CFLAGS} -O2 -Wall -Wextra -Wshadow -fvisibility=hidden -fdata-sections -ffunction-sections";\
	export LDFLAGS="$${LDFLAGS} -fvisibility=hidden -fdata-sections -ffunction-sections -Wl,--gc-sections -Wl,--as-needed";\
	make $(MAKEOPTS) all -C $(BUILDROOT)/efreet/compile;\
	else\
		echo "efreet is up to date.";\
	fi
	$(V)if test ! -f $(BUILDROOT)/efreet/stamps/compile -o -f $(BUILDROOT)/efreet/stamps/compile-updated; then\
		touch $(BUILDROOT)/efreet/stamps/compile;\
		echo "Compile updated, needs reinstall.";\
	fi
	$(V)echo "Success compiling efreet."

$(BUILDROOT)/efreet/stamps/install: $(BUILDROOT)/efreet/stamps/compile efreet-install
efreet-install: $(BUILDROOT)/efreet/stamps/compile
	$(V)echo "Installing efreet..."
	$(V)if test ! -f $(BUILDROOT)/efreet/stamps/install -o $(BUILDROOT)/efreet/stamps/compile -nt $(BUILDROOT)/efreet/stamps/install; then\
		rm -f $(BUILDROOT)/efreet/stamps/install;\
		echo "make $(MAKEOPTS) install -C $(BUILDROOT)/efreet/compile";\
		export PATH="$(INSTALLROOT)/bin:$${PATH}";\
	export PKG_CONFIG_PATH="$(INSTALLROOT)/lib/pkgconfig";\
	export CXXFLAGS="$${CXXFLAGS} -O2 -Wall -Wextra -Wshadow -fvisibility=hidden -fdata-sections -ffunction-sections";\
	export CFLAGS="$${CFLAGS} -O2 -Wall -Wextra -Wshadow -fvisibility=hidden -fdata-sections -ffunction-sections";\
	export LDFLAGS="$${LDFLAGS} -fvisibility=hidden -fdata-sections -ffunction-sections -Wl,--gc-sections -Wl,--as-needed";\
	make $(MAKEOPTS) install -C $(BUILDROOT)/efreet/compile;\
		mkdir -p $(BUILDROOT)/efreet/stamps;\
		touch $(BUILDROOT)/efreet/stamps/install;\
	else\
		echo "efreet did not change, not need to reinstall.";\
	fi
	$(V)echo "Success installing efreet."

$(BUILDROOT)/efreet/stamps/test: $(BUILDROOT)/efreet/stamps/compile efreet-test
efreet-test: $(BUILDROOT)/efreet/stamps/compile
	$(V)echo "Testing (make coverage) efreet..."
	$(V)rm -f $(BUILDROOT)/efreet/stamps/test
	export PATH="$(INSTALLROOT)/bin:$${PATH}";\
	export PKG_CONFIG_PATH="$(INSTALLROOT)/lib/pkgconfig";\
	export CXXFLAGS="$${CXXFLAGS} -O2 -Wall -Wextra -Wshadow -fvisibility=hidden -fdata-sections -ffunction-sections";\
	export CFLAGS="$${CFLAGS} -O2 -Wall -Wextra -Wshadow -fvisibility=hidden -fdata-sections -ffunction-sections";\
	export LDFLAGS="$${LDFLAGS} -fvisibility=hidden -fdata-sections -ffunction-sections -Wl,--gc-sections -Wl,--as-needed";\
	dbus-launch make $(MAKEOPTS) coverage -C $(BUILDROOT)/efreet/compile
	$(V)mkdir -p $(BUILDROOT)/efreet/stamps
	touch $(BUILDROOT)/efreet/stamps/test
	$(V)echo "Success testing (make coverage) efreet."

$(BUILDROOT)/efreet/stamps/doc: $(BUILDROOT)/efreet/stamps/compile efreet-doc
efreet-doc: $(BUILDROOT)/efreet/stamps/compile
	$(V)echo "Generating documentation (make doc) efreet..."
	$(V)rm -f $(BUILDROOT)/efreet/stamps/doc
	export PATH="$(INSTALLROOT)/bin:$${PATH}";\
	export PKG_CONFIG_PATH="$(INSTALLROOT)/lib/pkgconfig";\
	export CXXFLAGS="$${CXXFLAGS} -O2 -Wall -Wextra -Wshadow -fvisibility=hidden -fdata-sections -ffunction-sections";\
	export CFLAGS="$${CFLAGS} -O2 -Wall -Wextra -Wshadow -fvisibility=hidden -fdata-sections -ffunction-sections";\
	export LDFLAGS="$${LDFLAGS} -fvisibility=hidden -fdata-sections -ffunction-sections -Wl,--gc-sections -Wl,--as-needed";\
	make $(MAKEOPTS) doc -C $(BUILDROOT)/efreet/compile
	$(V)mkdir -p $(BUILDROOT)/efreet/stamps
	touch $(BUILDROOT)/efreet/stamps/doc
	$(V)echo "Success generating documentation (make doc) efreet."

$(BUILDROOT)/efreet/stamps/distcheck: $(BUILDROOT)/efreet/stamps/compile efreet-distcheck
efreet-distcheck: $(BUILDROOT)/efreet/stamps/compile
	$(V)echo "Checking distribution efreet..."
	$(V)rm -f $(BUILDROOT)/efreet/stamps/distcheck
	export PATH="$(INSTALLROOT)/bin:$${PATH}";\
	export PKG_CONFIG_PATH="$(INSTALLROOT)/lib/pkgconfig";\
	export CXXFLAGS="$${CXXFLAGS} -O2 -Wall -Wextra -Wshadow -fvisibility=hidden -fdata-sections -ffunction-sections";\
	export CFLAGS="$${CFLAGS} -O2 -Wall -Wextra -Wshadow -fvisibility=hidden -fdata-sections -ffunction-sections";\
	export LDFLAGS="$${LDFLAGS} -fvisibility=hidden -fdata-sections -ffunction-sections -Wl,--gc-sections -Wl,--as-needed";\
	make $(MAKEOPTS) distcheck -C $(BUILDROOT)/efreet/compile
	$(V)mkdir -p $(BUILDROOT)/efreet/stamps
	touch $(BUILDROOT)/efreet/stamps/distcheck
	$(V)echo "Success checking distribution efreet."

efreet-direct-users-compile: elementary-compile e-compile terminology-compile

efreet-all-users-compile: elementary-compile clouseau-compile e-compile terminology-compile

########################################################################
# edje rules
edje-dependencies: $(BUILDROOT)/edje/stamps/dependencies efl-install
$(BUILDROOT)/edje/stamps/dependencies: $(BUILDROOT)/efl/stamps/install
	$(V)mkdir -p $(BUILDROOT)/edje/stamps
	touch $(BUILDROOT)/edje/stamps/dependencies

edje-clean:
	if test -d $(BUILDROOT)/edje/compile; then chmod -R u+w $(BUILDROOT)/edje/compile; fi
	rm -fr $(BUILDROOT)/edje/compile
	rm -fr $(BUILDROOT)/edje/stamps

$(BUILDROOT)/edje/stamps/autogen: $(SRCROOT)/edje/autogen.sh $(SRCROOT)/edje/configure.ac
	$(V)echo "Running 'autogen.sh' for edje..."
	$(V)rm -f $(BUILDROOT)/edje/stamps/autogen
	cd $(SRCROOT)/edje && NOCONFIGURE=1 ./autogen.sh
	$(V)mkdir -p $(BUILDROOT)/edje/stamps
	touch $(BUILDROOT)/edje/stamps/autogen
	$(V)echo "Success running 'autogen.sh' for edje."

$(BUILDROOT)/edje/stamps/configure: $(BUILDROOT)/edje/stamps/autogen $(BUILDROOT)/edje/stamps/dependencies
	$(V)echo "Configuring edje..."
	$(V)rm -f $(BUILDROOT)/edje/stamps/configure
	$(V)mkdir -p $(BUILDROOT)/edje/compile
	export PATH="$(INSTALLROOT)/bin:$${PATH}";\
	export PKG_CONFIG_PATH="$(INSTALLROOT)/lib/pkgconfig";\
	export CXXFLAGS="$${CXXFLAGS} -O2 -Wall -Wextra -Wshadow -fvisibility=hidden -fdata-sections -ffunction-sections";\
	export CFLAGS="$${CFLAGS} -O2 -Wall -Wextra -Wshadow -fvisibility=hidden -fdata-sections -ffunction-sections";\
	export LDFLAGS="$${LDFLAGS} -fvisibility=hidden -fdata-sections -ffunction-sections -Wl,--gc-sections -Wl,--as-needed";\
	cd $(BUILDROOT)/edje/compile && \
	$(SRCROOT)/edje/configure --prefix=$(INSTALLROOT) --enable-tests \
		--enable-doc \
		--enable-coverage
	$(V)mkdir -p $(BUILDROOT)/edje/stamps
	touch $(BUILDROOT)/edje/stamps/configure
	$(V)echo "Success configuring edje."

$(BUILDROOT)/edje/stamps/compile: $(BUILDROOT)/edje/stamps/configure edje-compile
edje-compile: $(BUILDROOT)/edje/stamps/configure
	$(V)echo "Compiling edje..."
	$(V)rm -f $(BUILDROOT)/edje/stamps/compile-updated
	$(V)mkdir -p $(BUILDROOT)/edje/stamps
	$(V)if make --dry-run $(MAKEOPTS) all -C $(BUILDROOT)/edje/compile 2>/dev/null | grep -e 'libtool ' >/dev/null 2>/dev/null; then\
		touch $(BUILDROOT)/edje/stamps/compile-updated;\
	fi
	$(V)if test -f $(BUILDROOT)/edje/stamps/compile-updated; then\
		echo "make $(MAKEOPTS) all -C $(BUILDROOT)/edje/compile";\
		export PATH="$(INSTALLROOT)/bin:$${PATH}";\
	export PKG_CONFIG_PATH="$(INSTALLROOT)/lib/pkgconfig";\
	export CXXFLAGS="$${CXXFLAGS} -O2 -Wall -Wextra -Wshadow -fvisibility=hidden -fdata-sections -ffunction-sections";\
	export CFLAGS="$${CFLAGS} -O2 -Wall -Wextra -Wshadow -fvisibility=hidden -fdata-sections -ffunction-sections";\
	export LDFLAGS="$${LDFLAGS} -fvisibility=hidden -fdata-sections -ffunction-sections -Wl,--gc-sections -Wl,--as-needed";\
	make $(MAKEOPTS) all -C $(BUILDROOT)/edje/compile;\
	else\
		echo "edje is up to date.";\
	fi
	$(V)if test ! -f $(BUILDROOT)/edje/stamps/compile -o -f $(BUILDROOT)/edje/stamps/compile-updated; then\
		touch $(BUILDROOT)/edje/stamps/compile;\
		echo "Compile updated, needs reinstall.";\
	fi
	$(V)echo "Success compiling edje."

$(BUILDROOT)/edje/stamps/install: $(BUILDROOT)/edje/stamps/compile edje-install
edje-install: $(BUILDROOT)/edje/stamps/compile
	$(V)echo "Installing edje..."
	$(V)if test ! -f $(BUILDROOT)/edje/stamps/install -o $(BUILDROOT)/edje/stamps/compile -nt $(BUILDROOT)/edje/stamps/install; then\
		rm -f $(BUILDROOT)/edje/stamps/install;\
		echo "make $(MAKEOPTS) install -C $(BUILDROOT)/edje/compile";\
		export PATH="$(INSTALLROOT)/bin:$${PATH}";\
	export PKG_CONFIG_PATH="$(INSTALLROOT)/lib/pkgconfig";\
	export CXXFLAGS="$${CXXFLAGS} -O2 -Wall -Wextra -Wshadow -fvisibility=hidden -fdata-sections -ffunction-sections";\
	export CFLAGS="$${CFLAGS} -O2 -Wall -Wextra -Wshadow -fvisibility=hidden -fdata-sections -ffunction-sections";\
	export LDFLAGS="$${LDFLAGS} -fvisibility=hidden -fdata-sections -ffunction-sections -Wl,--gc-sections -Wl,--as-needed";\
	make $(MAKEOPTS) install -C $(BUILDROOT)/edje/compile;\
		mkdir -p $(BUILDROOT)/edje/stamps;\
		touch $(BUILDROOT)/edje/stamps/install;\
	else\
		echo "edje did not change, not need to reinstall.";\
	fi
	$(V)echo "Success installing edje."

$(BUILDROOT)/edje/stamps/test: $(BUILDROOT)/edje/stamps/compile edje-test
edje-test: $(BUILDROOT)/edje/stamps/compile
	$(V)echo "Testing (make coverage) edje..."
	$(V)rm -f $(BUILDROOT)/edje/stamps/test
	export PATH="$(INSTALLROOT)/bin:$${PATH}";\
	export PKG_CONFIG_PATH="$(INSTALLROOT)/lib/pkgconfig";\
	export CXXFLAGS="$${CXXFLAGS} -O2 -Wall -Wextra -Wshadow -fvisibility=hidden -fdata-sections -ffunction-sections";\
	export CFLAGS="$${CFLAGS} -O2 -Wall -Wextra -Wshadow -fvisibility=hidden -fdata-sections -ffunction-sections";\
	export LDFLAGS="$${LDFLAGS} -fvisibility=hidden -fdata-sections -ffunction-sections -Wl,--gc-sections -Wl,--as-needed";\
	dbus-launch make $(MAKEOPTS) coverage -C $(BUILDROOT)/edje/compile
	$(V)mkdir -p $(BUILDROOT)/edje/stamps
	touch $(BUILDROOT)/edje/stamps/test
	$(V)echo "Success testing (make coverage) edje."

$(BUILDROOT)/edje/stamps/doc: $(BUILDROOT)/edje/stamps/compile edje-doc
edje-doc: $(BUILDROOT)/edje/stamps/compile
	$(V)echo "Generating documentation (make doc) edje..."
	$(V)rm -f $(BUILDROOT)/edje/stamps/doc
	export PATH="$(INSTALLROOT)/bin:$${PATH}";\
	export PKG_CONFIG_PATH="$(INSTALLROOT)/lib/pkgconfig";\
	export CXXFLAGS="$${CXXFLAGS} -O2 -Wall -Wextra -Wshadow -fvisibility=hidden -fdata-sections -ffunction-sections";\
	export CFLAGS="$${CFLAGS} -O2 -Wall -Wextra -Wshadow -fvisibility=hidden -fdata-sections -ffunction-sections";\
	export LDFLAGS="$${LDFLAGS} -fvisibility=hidden -fdata-sections -ffunction-sections -Wl,--gc-sections -Wl,--as-needed";\
	make $(MAKEOPTS) doc -C $(BUILDROOT)/edje/compile
	$(V)mkdir -p $(BUILDROOT)/edje/stamps
	touch $(BUILDROOT)/edje/stamps/doc
	$(V)echo "Success generating documentation (make doc) edje."

$(BUILDROOT)/edje/stamps/distcheck: $(BUILDROOT)/edje/stamps/compile edje-distcheck
edje-distcheck: $(BUILDROOT)/edje/stamps/compile
	$(V)echo "Checking distribution edje..."
	$(V)rm -f $(BUILDROOT)/edje/stamps/distcheck
	export PATH="$(INSTALLROOT)/bin:$${PATH}";\
	export PKG_CONFIG_PATH="$(INSTALLROOT)/lib/pkgconfig";\
	export CXXFLAGS="$${CXXFLAGS} -O2 -Wall -Wextra -Wshadow -fvisibility=hidden -fdata-sections -ffunction-sections";\
	export CFLAGS="$${CFLAGS} -O2 -Wall -Wextra -Wshadow -fvisibility=hidden -fdata-sections -ffunction-sections";\
	export LDFLAGS="$${LDFLAGS} -fvisibility=hidden -fdata-sections -ffunction-sections -Wl,--gc-sections -Wl,--as-needed";\
	make $(MAKEOPTS) distcheck -C $(BUILDROOT)/edje/compile
	$(V)mkdir -p $(BUILDROOT)/edje/stamps
	touch $(BUILDROOT)/edje/stamps/distcheck
	$(V)echo "Success checking distribution edje."

edje-direct-users-compile: emotion-compile e-compile python-edje-compile elementary-compile clouseau-compile terminology-compile

edje-all-users-compile: emotion-compile e-compile python-edje-compile elementary-compile clouseau-compile terminology-compile

########################################################################
# python-edje rules
python-edje-dependencies: $(BUILDROOT)/python-edje/stamps/dependencies edje-install python-evas-install
$(BUILDROOT)/python-edje/stamps/dependencies: $(BUILDROOT)/edje/stamps/install $(BUILDROOT)/python-evas/stamps/install
	$(V)mkdir -p $(BUILDROOT)/python-edje/stamps
	touch $(BUILDROOT)/python-edje/stamps/dependencies

python-edje-clean:
	if test -d $(BUILDROOT)/python-edje/compile; then chmod -R u+w $(BUILDROOT)/python-edje/compile; fi
	rm -fr $(BUILDROOT)/python-edje/compile
	rm -fr $(BUILDROOT)/python-edje/stamps

$(BUILDROOT)/python-edje/stamps/autogen: $(SRCROOT)/BINDINGS/python/python-edje/autogen.sh $(SRCROOT)/BINDINGS/python/python-edje/configure.ac
	$(V)echo "Running 'autogen.sh' for python-edje..."
	$(V)rm -f $(BUILDROOT)/python-edje/stamps/autogen
	cd $(SRCROOT)/BINDINGS/python/python-edje && NOCONFIGURE=1 ./autogen.sh
	$(V)mkdir -p $(BUILDROOT)/python-edje/stamps
	touch $(BUILDROOT)/python-edje/stamps/autogen
	$(V)echo "Success running 'autogen.sh' for python-edje."

$(BUILDROOT)/python-edje/stamps/configure: $(BUILDROOT)/python-edje/stamps/autogen $(BUILDROOT)/python-edje/stamps/dependencies
	$(V)echo "Configuring python-edje..."
	$(V)rm -f $(BUILDROOT)/python-edje/stamps/configure
	$(V)mkdir -p $(BUILDROOT)/python-edje/compile
	export PATH="$(INSTALLROOT)/bin:$${PATH}";\
	export PKG_CONFIG_PATH="$(INSTALLROOT)/lib/pkgconfig";\
	export CXXFLAGS="$${CXXFLAGS} -O2 -Wall -Wextra -Wshadow -fvisibility=hidden -fdata-sections -ffunction-sections";\
	export CFLAGS="$${CFLAGS} -O2 -Wall -Wextra -Wshadow -fvisibility=hidden -fdata-sections -ffunction-sections -Wno-unused-parameter -Wno-unused-but-set-variable -Wno-shadow -Wno-strict-aliasing";\
	export LDFLAGS="$${LDFLAGS} -fvisibility=hidden -fdata-sections -ffunction-sections -Wl,--gc-sections -Wl,--as-needed";\
	cd $(BUILDROOT)/python-edje/compile && \
	$(SRCROOT)/BINDINGS/python/python-edje/configure --prefix=$(INSTALLROOT) 
	$(V)mkdir -p $(BUILDROOT)/python-edje/stamps
	touch $(BUILDROOT)/python-edje/stamps/configure
	$(V)echo "Success configuring python-edje."

$(BUILDROOT)/python-edje/stamps/compile: $(BUILDROOT)/python-edje/stamps/configure python-edje-compile
python-edje-compile: $(BUILDROOT)/python-edje/stamps/configure
	$(V)echo "Compiling python-edje..."
	$(V)rm -f $(BUILDROOT)/python-edje/stamps/compile-updated
	$(V)mkdir -p $(BUILDROOT)/python-edje/stamps
	$(V)if make --dry-run $(MAKEOPTS) all -C $(BUILDROOT)/python-edje/compile 2>/dev/null | grep -e 'libtool ' >/dev/null 2>/dev/null; then\
		touch $(BUILDROOT)/python-edje/stamps/compile-updated;\
	fi
	$(V)if test -f $(BUILDROOT)/python-edje/stamps/compile-updated; then\
		echo "make $(MAKEOPTS) all -C $(BUILDROOT)/python-edje/compile";\
		export PATH="$(INSTALLROOT)/bin:$${PATH}";\
	export PKG_CONFIG_PATH="$(INSTALLROOT)/lib/pkgconfig";\
	export CXXFLAGS="$${CXXFLAGS} -O2 -Wall -Wextra -Wshadow -fvisibility=hidden -fdata-sections -ffunction-sections";\
	export CFLAGS="$${CFLAGS} -O2 -Wall -Wextra -Wshadow -fvisibility=hidden -fdata-sections -ffunction-sections -Wno-unused-parameter -Wno-unused-but-set-variable -Wno-shadow -Wno-strict-aliasing";\
	export LDFLAGS="$${LDFLAGS} -fvisibility=hidden -fdata-sections -ffunction-sections -Wl,--gc-sections -Wl,--as-needed";\
	make $(MAKEOPTS) all -C $(BUILDROOT)/python-edje/compile;\
	else\
		echo "python-edje is up to date.";\
	fi
	$(V)if test ! -f $(BUILDROOT)/python-edje/stamps/compile -o -f $(BUILDROOT)/python-edje/stamps/compile-updated; then\
		touch $(BUILDROOT)/python-edje/stamps/compile;\
		echo "Compile updated, needs reinstall.";\
	fi
	$(V)echo "Success compiling python-edje."

$(BUILDROOT)/python-edje/stamps/install: $(BUILDROOT)/python-edje/stamps/compile python-edje-install
python-edje-install: $(BUILDROOT)/python-edje/stamps/compile
	$(V)echo "Installing python-edje..."
	$(V)if test ! -f $(BUILDROOT)/python-edje/stamps/install -o $(BUILDROOT)/python-edje/stamps/compile -nt $(BUILDROOT)/python-edje/stamps/install; then\
		rm -f $(BUILDROOT)/python-edje/stamps/install;\
		echo "make $(MAKEOPTS) install -C $(BUILDROOT)/python-edje/compile";\
		export PATH="$(INSTALLROOT)/bin:$${PATH}";\
	export PKG_CONFIG_PATH="$(INSTALLROOT)/lib/pkgconfig";\
	export CXXFLAGS="$${CXXFLAGS} -O2 -Wall -Wextra -Wshadow -fvisibility=hidden -fdata-sections -ffunction-sections";\
	export CFLAGS="$${CFLAGS} -O2 -Wall -Wextra -Wshadow -fvisibility=hidden -fdata-sections -ffunction-sections -Wno-unused-parameter -Wno-unused-but-set-variable -Wno-shadow -Wno-strict-aliasing";\
	export LDFLAGS="$${LDFLAGS} -fvisibility=hidden -fdata-sections -ffunction-sections -Wl,--gc-sections -Wl,--as-needed";\
	make $(MAKEOPTS) install -C $(BUILDROOT)/python-edje/compile;\
		mkdir -p $(BUILDROOT)/python-edje/stamps;\
		touch $(BUILDROOT)/python-edje/stamps/install;\
	else\
		echo "python-edje did not change, not need to reinstall.";\
	fi
	$(V)echo "Success installing python-edje."

$(BUILDROOT)/python-edje/stamps/test: $(BUILDROOT)/python-edje/stamps/compile python-edje-test
python-edje-test: $(BUILDROOT)/python-edje/stamps/compile
	$(V)mkdir -p $(BUILDROOT)/python-edje/stamps
	touch $(BUILDROOT)/python-edje/stamps/test
	$(V)echo 'No test target defined for python-edje'

$(BUILDROOT)/python-edje/stamps/doc: $(BUILDROOT)/python-edje/stamps/compile python-edje-doc
python-edje-doc: $(BUILDROOT)/python-edje/stamps/compile
	$(V)mkdir -p $(BUILDROOT)/python-edje/stamps
	touch $(BUILDROOT)/python-edje/stamps/doc
	$(V)echo 'No doc target defined for python-edje'

$(BUILDROOT)/python-edje/stamps/distcheck: $(BUILDROOT)/python-edje/stamps/compile python-edje-distcheck
python-edje-distcheck: $(BUILDROOT)/python-edje/stamps/compile
	$(V)echo "Checking distribution python-edje..."
	$(V)rm -f $(BUILDROOT)/python-edje/stamps/distcheck
	export PATH="$(INSTALLROOT)/bin:$${PATH}";\
	export PKG_CONFIG_PATH="$(INSTALLROOT)/lib/pkgconfig";\
	export CXXFLAGS="$${CXXFLAGS} -O2 -Wall -Wextra -Wshadow -fvisibility=hidden -fdata-sections -ffunction-sections";\
	export CFLAGS="$${CFLAGS} -O2 -Wall -Wextra -Wshadow -fvisibility=hidden -fdata-sections -ffunction-sections -Wno-unused-parameter -Wno-unused-but-set-variable -Wno-shadow -Wno-strict-aliasing";\
	export LDFLAGS="$${LDFLAGS} -fvisibility=hidden -fdata-sections -ffunction-sections -Wl,--gc-sections -Wl,--as-needed";\
	make $(MAKEOPTS) distcheck -C $(BUILDROOT)/python-edje/compile
	$(V)mkdir -p $(BUILDROOT)/python-edje/stamps
	touch $(BUILDROOT)/python-edje/stamps/distcheck
	$(V)echo "Success checking distribution python-edje."

python-edje-direct-users-compile:

python-edje-all-users-compile:

########################################################################
# emotion rules
emotion-dependencies: $(BUILDROOT)/emotion/stamps/dependencies edje-install efl-install eeze-install
$(BUILDROOT)/emotion/stamps/dependencies: $(BUILDROOT)/edje/stamps/install $(BUILDROOT)/efl/stamps/install $(BUILDROOT)/eeze/stamps/install
	$(V)mkdir -p $(BUILDROOT)/emotion/stamps
	touch $(BUILDROOT)/emotion/stamps/dependencies

emotion-clean:
	if test -d $(BUILDROOT)/emotion/compile; then chmod -R u+w $(BUILDROOT)/emotion/compile; fi
	rm -fr $(BUILDROOT)/emotion/compile
	rm -fr $(BUILDROOT)/emotion/stamps

$(BUILDROOT)/emotion/stamps/autogen: $(SRCROOT)/emotion/autogen.sh $(SRCROOT)/emotion/configure.ac
	$(V)echo "Running 'autogen.sh' for emotion..."
	$(V)rm -f $(BUILDROOT)/emotion/stamps/autogen
	cd $(SRCROOT)/emotion && NOCONFIGURE=1 ./autogen.sh
	$(V)mkdir -p $(BUILDROOT)/emotion/stamps
	touch $(BUILDROOT)/emotion/stamps/autogen
	$(V)echo "Success running 'autogen.sh' for emotion."

$(BUILDROOT)/emotion/stamps/configure: $(BUILDROOT)/emotion/stamps/autogen $(BUILDROOT)/emotion/stamps/dependencies
	$(V)echo "Configuring emotion..."
	$(V)rm -f $(BUILDROOT)/emotion/stamps/configure
	$(V)mkdir -p $(BUILDROOT)/emotion/compile
	export PATH="$(INSTALLROOT)/bin:$${PATH}";\
	export PKG_CONFIG_PATH="$(INSTALLROOT)/lib/pkgconfig";\
	export CXXFLAGS="$${CXXFLAGS} -O2 -Wall -Wextra -Wshadow -fvisibility=hidden -fdata-sections -ffunction-sections";\
	export CFLAGS="$${CFLAGS} -O2 -Wall -Wextra -Wshadow -fvisibility=hidden -fdata-sections -ffunction-sections";\
	export LDFLAGS="$${LDFLAGS} -fvisibility=hidden -fdata-sections -ffunction-sections -Wl,--gc-sections -Wl,--as-needed";\
	cd $(BUILDROOT)/emotion/compile && \
	$(SRCROOT)/emotion/configure --prefix=$(INSTALLROOT) 
	$(V)mkdir -p $(BUILDROOT)/emotion/stamps
	touch $(BUILDROOT)/emotion/stamps/configure
	$(V)echo "Success configuring emotion."

$(BUILDROOT)/emotion/stamps/compile: $(BUILDROOT)/emotion/stamps/configure emotion-compile
emotion-compile: $(BUILDROOT)/emotion/stamps/configure
	$(V)echo "Compiling emotion..."
	$(V)rm -f $(BUILDROOT)/emotion/stamps/compile-updated
	$(V)mkdir -p $(BUILDROOT)/emotion/stamps
	$(V)if make --dry-run $(MAKEOPTS) all -C $(BUILDROOT)/emotion/compile 2>/dev/null | grep -e 'libtool ' >/dev/null 2>/dev/null; then\
		touch $(BUILDROOT)/emotion/stamps/compile-updated;\
	fi
	$(V)if test -f $(BUILDROOT)/emotion/stamps/compile-updated; then\
		echo "make $(MAKEOPTS) all -C $(BUILDROOT)/emotion/compile";\
		export PATH="$(INSTALLROOT)/bin:$${PATH}";\
	export PKG_CONFIG_PATH="$(INSTALLROOT)/lib/pkgconfig";\
	export CXXFLAGS="$${CXXFLAGS} -O2 -Wall -Wextra -Wshadow -fvisibility=hidden -fdata-sections -ffunction-sections";\
	export CFLAGS="$${CFLAGS} -O2 -Wall -Wextra -Wshadow -fvisibility=hidden -fdata-sections -ffunction-sections";\
	export LDFLAGS="$${LDFLAGS} -fvisibility=hidden -fdata-sections -ffunction-sections -Wl,--gc-sections -Wl,--as-needed";\
	make $(MAKEOPTS) all -C $(BUILDROOT)/emotion/compile;\
	else\
		echo "emotion is up to date.";\
	fi
	$(V)if test ! -f $(BUILDROOT)/emotion/stamps/compile -o -f $(BUILDROOT)/emotion/stamps/compile-updated; then\
		touch $(BUILDROOT)/emotion/stamps/compile;\
		echo "Compile updated, needs reinstall.";\
	fi
	$(V)echo "Success compiling emotion."

$(BUILDROOT)/emotion/stamps/install: $(BUILDROOT)/emotion/stamps/compile emotion-install
emotion-install: $(BUILDROOT)/emotion/stamps/compile
	$(V)echo "Installing emotion..."
	$(V)if test ! -f $(BUILDROOT)/emotion/stamps/install -o $(BUILDROOT)/emotion/stamps/compile -nt $(BUILDROOT)/emotion/stamps/install; then\
		rm -f $(BUILDROOT)/emotion/stamps/install;\
		echo "make $(MAKEOPTS) install -C $(BUILDROOT)/emotion/compile";\
		export PATH="$(INSTALLROOT)/bin:$${PATH}";\
	export PKG_CONFIG_PATH="$(INSTALLROOT)/lib/pkgconfig";\
	export CXXFLAGS="$${CXXFLAGS} -O2 -Wall -Wextra -Wshadow -fvisibility=hidden -fdata-sections -ffunction-sections";\
	export CFLAGS="$${CFLAGS} -O2 -Wall -Wextra -Wshadow -fvisibility=hidden -fdata-sections -ffunction-sections";\
	export LDFLAGS="$${LDFLAGS} -fvisibility=hidden -fdata-sections -ffunction-sections -Wl,--gc-sections -Wl,--as-needed";\
	make $(MAKEOPTS) install -C $(BUILDROOT)/emotion/compile;\
		mkdir -p $(BUILDROOT)/emotion/stamps;\
		touch $(BUILDROOT)/emotion/stamps/install;\
	else\
		echo "emotion did not change, not need to reinstall.";\
	fi
	$(V)echo "Success installing emotion."

$(BUILDROOT)/emotion/stamps/test: $(BUILDROOT)/emotion/stamps/compile emotion-test
emotion-test: $(BUILDROOT)/emotion/stamps/compile
	$(V)mkdir -p $(BUILDROOT)/emotion/stamps
	touch $(BUILDROOT)/emotion/stamps/test
	$(V)echo 'No test target defined for emotion'

$(BUILDROOT)/emotion/stamps/doc: $(BUILDROOT)/emotion/stamps/compile emotion-doc
emotion-doc: $(BUILDROOT)/emotion/stamps/compile
	$(V)echo "Generating documentation (make doc) emotion..."
	$(V)rm -f $(BUILDROOT)/emotion/stamps/doc
	export PATH="$(INSTALLROOT)/bin:$${PATH}";\
	export PKG_CONFIG_PATH="$(INSTALLROOT)/lib/pkgconfig";\
	export CXXFLAGS="$${CXXFLAGS} -O2 -Wall -Wextra -Wshadow -fvisibility=hidden -fdata-sections -ffunction-sections";\
	export CFLAGS="$${CFLAGS} -O2 -Wall -Wextra -Wshadow -fvisibility=hidden -fdata-sections -ffunction-sections";\
	export LDFLAGS="$${LDFLAGS} -fvisibility=hidden -fdata-sections -ffunction-sections -Wl,--gc-sections -Wl,--as-needed";\
	make $(MAKEOPTS) doc -C $(BUILDROOT)/emotion/compile
	$(V)mkdir -p $(BUILDROOT)/emotion/stamps
	touch $(BUILDROOT)/emotion/stamps/doc
	$(V)echo "Success generating documentation (make doc) emotion."

$(BUILDROOT)/emotion/stamps/distcheck: $(BUILDROOT)/emotion/stamps/compile emotion-distcheck
emotion-distcheck: $(BUILDROOT)/emotion/stamps/compile
	$(V)echo "Checking distribution emotion..."
	$(V)rm -f $(BUILDROOT)/emotion/stamps/distcheck
	export PATH="$(INSTALLROOT)/bin:$${PATH}";\
	export PKG_CONFIG_PATH="$(INSTALLROOT)/lib/pkgconfig";\
	export CXXFLAGS="$${CXXFLAGS} -O2 -Wall -Wextra -Wshadow -fvisibility=hidden -fdata-sections -ffunction-sections";\
	export CFLAGS="$${CFLAGS} -O2 -Wall -Wextra -Wshadow -fvisibility=hidden -fdata-sections -ffunction-sections";\
	export LDFLAGS="$${LDFLAGS} -fvisibility=hidden -fdata-sections -ffunction-sections -Wl,--gc-sections -Wl,--as-needed";\
	make $(MAKEOPTS) distcheck -C $(BUILDROOT)/emotion/compile
	$(V)mkdir -p $(BUILDROOT)/emotion/stamps
	touch $(BUILDROOT)/emotion/stamps/distcheck
	$(V)echo "Success checking distribution emotion."

emotion-direct-users-compile: elementary-compile terminology-compile

emotion-all-users-compile: elementary-compile clouseau-compile e-compile terminology-compile

########################################################################
# elementary rules
elementary-dependencies: $(BUILDROOT)/elementary/stamps/dependencies edje-install e_dbus-install efl-install emotion-install efreet-install
$(BUILDROOT)/elementary/stamps/dependencies: $(BUILDROOT)/edje/stamps/install $(BUILDROOT)/e_dbus/stamps/install $(BUILDROOT)/efl/stamps/install $(BUILDROOT)/emotion/stamps/install $(BUILDROOT)/efreet/stamps/install
	$(V)mkdir -p $(BUILDROOT)/elementary/stamps
	touch $(BUILDROOT)/elementary/stamps/dependencies

elementary-clean:
	if test -d $(BUILDROOT)/elementary/compile; then chmod -R u+w $(BUILDROOT)/elementary/compile; fi
	rm -fr $(BUILDROOT)/elementary/compile
	rm -fr $(BUILDROOT)/elementary/stamps

$(BUILDROOT)/elementary/stamps/autogen: $(SRCROOT)/elementary/autogen.sh $(SRCROOT)/elementary/configure.ac
	$(V)echo "Running 'autogen.sh' for elementary..."
	$(V)rm -f $(BUILDROOT)/elementary/stamps/autogen
	cd $(SRCROOT)/elementary && NOCONFIGURE=1 ./autogen.sh
	$(V)mkdir -p $(BUILDROOT)/elementary/stamps
	touch $(BUILDROOT)/elementary/stamps/autogen
	$(V)echo "Success running 'autogen.sh' for elementary."

$(BUILDROOT)/elementary/stamps/configure: $(BUILDROOT)/elementary/stamps/autogen $(BUILDROOT)/elementary/stamps/dependencies
	$(V)echo "Configuring elementary..."
	$(V)rm -f $(BUILDROOT)/elementary/stamps/configure
	$(V)mkdir -p $(BUILDROOT)/elementary/compile
	export PATH="$(INSTALLROOT)/bin:$${PATH}";\
	export PKG_CONFIG_PATH="$(INSTALLROOT)/lib/pkgconfig";\
	export CXXFLAGS="$${CXXFLAGS} -O2 -Wall -Wextra -Wshadow -fvisibility=hidden -fdata-sections -ffunction-sections";\
	export CFLAGS="$${CFLAGS} -O2 -Wall -Wextra -Wshadow -fvisibility=hidden -fdata-sections -ffunction-sections";\
	export LDFLAGS="$${LDFLAGS} -fvisibility=hidden -fdata-sections -ffunction-sections -Wl,--gc-sections -Wl,--as-needed";\
	cd $(BUILDROOT)/elementary/compile && \
	$(SRCROOT)/elementary/configure --prefix=$(INSTALLROOT) 
	$(V)mkdir -p $(BUILDROOT)/elementary/stamps
	touch $(BUILDROOT)/elementary/stamps/configure
	$(V)echo "Success configuring elementary."

$(BUILDROOT)/elementary/stamps/compile: $(BUILDROOT)/elementary/stamps/configure elementary-compile
elementary-compile: $(BUILDROOT)/elementary/stamps/configure
	$(V)echo "Compiling elementary..."
	$(V)rm -f $(BUILDROOT)/elementary/stamps/compile-updated
	$(V)mkdir -p $(BUILDROOT)/elementary/stamps
	$(V)if make --dry-run $(MAKEOPTS) all -C $(BUILDROOT)/elementary/compile 2>/dev/null | grep -e 'libtool ' >/dev/null 2>/dev/null; then\
		touch $(BUILDROOT)/elementary/stamps/compile-updated;\
	fi
	$(V)if test -f $(BUILDROOT)/elementary/stamps/compile-updated; then\
		echo "make $(MAKEOPTS) all -C $(BUILDROOT)/elementary/compile";\
		export PATH="$(INSTALLROOT)/bin:$${PATH}";\
	export PKG_CONFIG_PATH="$(INSTALLROOT)/lib/pkgconfig";\
	export CXXFLAGS="$${CXXFLAGS} -O2 -Wall -Wextra -Wshadow -fvisibility=hidden -fdata-sections -ffunction-sections";\
	export CFLAGS="$${CFLAGS} -O2 -Wall -Wextra -Wshadow -fvisibility=hidden -fdata-sections -ffunction-sections";\
	export LDFLAGS="$${LDFLAGS} -fvisibility=hidden -fdata-sections -ffunction-sections -Wl,--gc-sections -Wl,--as-needed";\
	make $(MAKEOPTS) all -C $(BUILDROOT)/elementary/compile;\
	else\
		echo "elementary is up to date.";\
	fi
	$(V)if test ! -f $(BUILDROOT)/elementary/stamps/compile -o -f $(BUILDROOT)/elementary/stamps/compile-updated; then\
		touch $(BUILDROOT)/elementary/stamps/compile;\
		echo "Compile updated, needs reinstall.";\
	fi
	$(V)echo "Success compiling elementary."

$(BUILDROOT)/elementary/stamps/install: $(BUILDROOT)/elementary/stamps/compile elementary-install
elementary-install: $(BUILDROOT)/elementary/stamps/compile
	$(V)echo "Installing elementary..."
	$(V)if test ! -f $(BUILDROOT)/elementary/stamps/install -o $(BUILDROOT)/elementary/stamps/compile -nt $(BUILDROOT)/elementary/stamps/install; then\
		rm -f $(BUILDROOT)/elementary/stamps/install;\
		echo "make $(MAKEOPTS) install -C $(BUILDROOT)/elementary/compile";\
		export PATH="$(INSTALLROOT)/bin:$${PATH}";\
	export PKG_CONFIG_PATH="$(INSTALLROOT)/lib/pkgconfig";\
	export CXXFLAGS="$${CXXFLAGS} -O2 -Wall -Wextra -Wshadow -fvisibility=hidden -fdata-sections -ffunction-sections";\
	export CFLAGS="$${CFLAGS} -O2 -Wall -Wextra -Wshadow -fvisibility=hidden -fdata-sections -ffunction-sections";\
	export LDFLAGS="$${LDFLAGS} -fvisibility=hidden -fdata-sections -ffunction-sections -Wl,--gc-sections -Wl,--as-needed";\
	make $(MAKEOPTS) install -C $(BUILDROOT)/elementary/compile;\
		mkdir -p $(BUILDROOT)/elementary/stamps;\
		touch $(BUILDROOT)/elementary/stamps/install;\
	else\
		echo "elementary did not change, not need to reinstall.";\
	fi
	$(V)echo "Success installing elementary."

$(BUILDROOT)/elementary/stamps/test: $(BUILDROOT)/elementary/stamps/compile elementary-test
elementary-test: $(BUILDROOT)/elementary/stamps/compile
	$(V)mkdir -p $(BUILDROOT)/elementary/stamps
	touch $(BUILDROOT)/elementary/stamps/test
	$(V)echo 'No test target defined for elementary'

$(BUILDROOT)/elementary/stamps/doc: $(BUILDROOT)/elementary/stamps/compile elementary-doc
elementary-doc: $(BUILDROOT)/elementary/stamps/compile
	$(V)mkdir -p $(BUILDROOT)/elementary/stamps
	touch $(BUILDROOT)/elementary/stamps/doc
	$(V)echo 'No doc target defined for elementary'

$(BUILDROOT)/elementary/stamps/distcheck: $(BUILDROOT)/elementary/stamps/compile elementary-distcheck
elementary-distcheck: $(BUILDROOT)/elementary/stamps/compile
	$(V)echo "Checking distribution elementary..."
	$(V)rm -f $(BUILDROOT)/elementary/stamps/distcheck
	export PATH="$(INSTALLROOT)/bin:$${PATH}";\
	export PKG_CONFIG_PATH="$(INSTALLROOT)/lib/pkgconfig";\
	export CXXFLAGS="$${CXXFLAGS} -O2 -Wall -Wextra -Wshadow -fvisibility=hidden -fdata-sections -ffunction-sections";\
	export CFLAGS="$${CFLAGS} -O2 -Wall -Wextra -Wshadow -fvisibility=hidden -fdata-sections -ffunction-sections";\
	export LDFLAGS="$${LDFLAGS} -fvisibility=hidden -fdata-sections -ffunction-sections -Wl,--gc-sections -Wl,--as-needed";\
	make $(MAKEOPTS) distcheck -C $(BUILDROOT)/elementary/compile
	$(V)mkdir -p $(BUILDROOT)/elementary/stamps
	touch $(BUILDROOT)/elementary/stamps/distcheck
	$(V)echo "Success checking distribution elementary."

elementary-direct-users-compile: clouseau-compile e-compile terminology-compile

elementary-all-users-compile: clouseau-compile e-compile terminology-compile

########################################################################
# terminology rules
terminology-dependencies: $(BUILDROOT)/terminology/stamps/dependencies edje-install emotion-install efl-install elementary-install efreet-install
$(BUILDROOT)/terminology/stamps/dependencies: $(BUILDROOT)/edje/stamps/install $(BUILDROOT)/emotion/stamps/install $(BUILDROOT)/efl/stamps/install $(BUILDROOT)/elementary/stamps/install $(BUILDROOT)/efreet/stamps/install
	$(V)mkdir -p $(BUILDROOT)/terminology/stamps
	touch $(BUILDROOT)/terminology/stamps/dependencies

terminology-clean:
	if test -d $(BUILDROOT)/terminology/compile; then chmod -R u+w $(BUILDROOT)/terminology/compile; fi
	rm -fr $(BUILDROOT)/terminology/compile
	rm -fr $(BUILDROOT)/terminology/stamps

$(BUILDROOT)/terminology/stamps/autogen: $(SRCROOT)/terminology/autogen.sh $(SRCROOT)/terminology/configure.ac
	$(V)echo "Running 'autogen.sh' for terminology..."
	$(V)rm -f $(BUILDROOT)/terminology/stamps/autogen
	cd $(SRCROOT)/terminology && NOCONFIGURE=1 ./autogen.sh
	$(V)mkdir -p $(BUILDROOT)/terminology/stamps
	touch $(BUILDROOT)/terminology/stamps/autogen
	$(V)echo "Success running 'autogen.sh' for terminology."

$(BUILDROOT)/terminology/stamps/configure: $(BUILDROOT)/terminology/stamps/autogen $(BUILDROOT)/terminology/stamps/dependencies
	$(V)echo "Configuring terminology..."
	$(V)rm -f $(BUILDROOT)/terminology/stamps/configure
	$(V)mkdir -p $(BUILDROOT)/terminology/compile
	export PATH="$(INSTALLROOT)/bin:$${PATH}";\
	export PKG_CONFIG_PATH="$(INSTALLROOT)/lib/pkgconfig";\
	export CXXFLAGS="$${CXXFLAGS} -O2 -Wall -Wextra -Wshadow -fvisibility=hidden -fdata-sections -ffunction-sections";\
	export CFLAGS="$${CFLAGS} -O2 -Wall -Wextra -Wshadow -fvisibility=hidden -fdata-sections -ffunction-sections";\
	export LDFLAGS="$${LDFLAGS} -fvisibility=hidden -fdata-sections -ffunction-sections -Wl,--gc-sections -Wl,--as-needed";\
	cd $(BUILDROOT)/terminology/compile && \
	$(SRCROOT)/terminology/configure --prefix=$(INSTALLROOT) 
	$(V)mkdir -p $(BUILDROOT)/terminology/stamps
	touch $(BUILDROOT)/terminology/stamps/configure
	$(V)echo "Success configuring terminology."

$(BUILDROOT)/terminology/stamps/compile: $(BUILDROOT)/terminology/stamps/configure terminology-compile
terminology-compile: $(BUILDROOT)/terminology/stamps/configure
	$(V)echo "Compiling terminology..."
	$(V)rm -f $(BUILDROOT)/terminology/stamps/compile-updated
	$(V)mkdir -p $(BUILDROOT)/terminology/stamps
	$(V)if make --dry-run $(MAKEOPTS) all -C $(BUILDROOT)/terminology/compile 2>/dev/null | grep -e 'libtool ' >/dev/null 2>/dev/null; then\
		touch $(BUILDROOT)/terminology/stamps/compile-updated;\
	fi
	$(V)if test -f $(BUILDROOT)/terminology/stamps/compile-updated; then\
		echo "make $(MAKEOPTS) all -C $(BUILDROOT)/terminology/compile";\
		export PATH="$(INSTALLROOT)/bin:$${PATH}";\
	export PKG_CONFIG_PATH="$(INSTALLROOT)/lib/pkgconfig";\
	export CXXFLAGS="$${CXXFLAGS} -O2 -Wall -Wextra -Wshadow -fvisibility=hidden -fdata-sections -ffunction-sections";\
	export CFLAGS="$${CFLAGS} -O2 -Wall -Wextra -Wshadow -fvisibility=hidden -fdata-sections -ffunction-sections";\
	export LDFLAGS="$${LDFLAGS} -fvisibility=hidden -fdata-sections -ffunction-sections -Wl,--gc-sections -Wl,--as-needed";\
	make $(MAKEOPTS) all -C $(BUILDROOT)/terminology/compile;\
	else\
		echo "terminology is up to date.";\
	fi
	$(V)if test ! -f $(BUILDROOT)/terminology/stamps/compile -o -f $(BUILDROOT)/terminology/stamps/compile-updated; then\
		touch $(BUILDROOT)/terminology/stamps/compile;\
		echo "Compile updated, needs reinstall.";\
	fi
	$(V)echo "Success compiling terminology."

$(BUILDROOT)/terminology/stamps/install: $(BUILDROOT)/terminology/stamps/compile terminology-install
terminology-install: $(BUILDROOT)/terminology/stamps/compile
	$(V)echo "Installing terminology..."
	$(V)if test ! -f $(BUILDROOT)/terminology/stamps/install -o $(BUILDROOT)/terminology/stamps/compile -nt $(BUILDROOT)/terminology/stamps/install; then\
		rm -f $(BUILDROOT)/terminology/stamps/install;\
		echo "make $(MAKEOPTS) install -C $(BUILDROOT)/terminology/compile";\
		export PATH="$(INSTALLROOT)/bin:$${PATH}";\
	export PKG_CONFIG_PATH="$(INSTALLROOT)/lib/pkgconfig";\
	export CXXFLAGS="$${CXXFLAGS} -O2 -Wall -Wextra -Wshadow -fvisibility=hidden -fdata-sections -ffunction-sections";\
	export CFLAGS="$${CFLAGS} -O2 -Wall -Wextra -Wshadow -fvisibility=hidden -fdata-sections -ffunction-sections";\
	export LDFLAGS="$${LDFLAGS} -fvisibility=hidden -fdata-sections -ffunction-sections -Wl,--gc-sections -Wl,--as-needed";\
	make $(MAKEOPTS) install -C $(BUILDROOT)/terminology/compile;\
		mkdir -p $(BUILDROOT)/terminology/stamps;\
		touch $(BUILDROOT)/terminology/stamps/install;\
	else\
		echo "terminology did not change, not need to reinstall.";\
	fi
	$(V)echo "Success installing terminology."

$(BUILDROOT)/terminology/stamps/test: $(BUILDROOT)/terminology/stamps/compile terminology-test
terminology-test: $(BUILDROOT)/terminology/stamps/compile
	$(V)mkdir -p $(BUILDROOT)/terminology/stamps
	touch $(BUILDROOT)/terminology/stamps/test
	$(V)echo 'No test target defined for terminology'

$(BUILDROOT)/terminology/stamps/doc: $(BUILDROOT)/terminology/stamps/compile terminology-doc
terminology-doc: $(BUILDROOT)/terminology/stamps/compile
	$(V)mkdir -p $(BUILDROOT)/terminology/stamps
	touch $(BUILDROOT)/terminology/stamps/doc
	$(V)echo 'No doc target defined for terminology'

$(BUILDROOT)/terminology/stamps/distcheck: $(BUILDROOT)/terminology/stamps/compile terminology-distcheck
terminology-distcheck: $(BUILDROOT)/terminology/stamps/compile
	$(V)echo "Checking distribution terminology..."
	$(V)rm -f $(BUILDROOT)/terminology/stamps/distcheck
	export PATH="$(INSTALLROOT)/bin:$${PATH}";\
	export PKG_CONFIG_PATH="$(INSTALLROOT)/lib/pkgconfig";\
	export CXXFLAGS="$${CXXFLAGS} -O2 -Wall -Wextra -Wshadow -fvisibility=hidden -fdata-sections -ffunction-sections";\
	export CFLAGS="$${CFLAGS} -O2 -Wall -Wextra -Wshadow -fvisibility=hidden -fdata-sections -ffunction-sections";\
	export LDFLAGS="$${LDFLAGS} -fvisibility=hidden -fdata-sections -ffunction-sections -Wl,--gc-sections -Wl,--as-needed";\
	make $(MAKEOPTS) distcheck -C $(BUILDROOT)/terminology/compile
	$(V)mkdir -p $(BUILDROOT)/terminology/stamps
	touch $(BUILDROOT)/terminology/stamps/distcheck
	$(V)echo "Success checking distribution terminology."

terminology-direct-users-compile:

terminology-all-users-compile:

########################################################################
# e rules
e-dependencies: $(BUILDROOT)/e/stamps/dependencies edje-install eeze-install efreet-install elementary-install efl-install e_dbus-install
$(BUILDROOT)/e/stamps/dependencies: $(BUILDROOT)/edje/stamps/install $(BUILDROOT)/eeze/stamps/install $(BUILDROOT)/efreet/stamps/install $(BUILDROOT)/elementary/stamps/install $(BUILDROOT)/efl/stamps/install $(BUILDROOT)/e_dbus/stamps/install
	$(V)mkdir -p $(BUILDROOT)/e/stamps
	touch $(BUILDROOT)/e/stamps/dependencies

e-clean:
	if test -d $(BUILDROOT)/e/compile; then chmod -R u+w $(BUILDROOT)/e/compile; fi
	rm -fr $(BUILDROOT)/e/compile
	rm -fr $(BUILDROOT)/e/stamps

$(BUILDROOT)/e/stamps/autogen: $(SRCROOT)/e/autogen.sh $(SRCROOT)/e/configure.ac
	$(V)echo "Running 'autogen.sh' for e..."
	$(V)rm -f $(BUILDROOT)/e/stamps/autogen
	cd $(SRCROOT)/e && NOCONFIGURE=1 ./autogen.sh
	$(V)mkdir -p $(BUILDROOT)/e/stamps
	touch $(BUILDROOT)/e/stamps/autogen
	$(V)echo "Success running 'autogen.sh' for e."

$(BUILDROOT)/e/stamps/configure: $(BUILDROOT)/e/stamps/autogen $(BUILDROOT)/e/stamps/dependencies
	$(V)echo "Configuring e..."
	$(V)rm -f $(BUILDROOT)/e/stamps/configure
	$(V)mkdir -p $(BUILDROOT)/e/compile
	export PATH="$(INSTALLROOT)/bin:$${PATH}";\
	export PKG_CONFIG_PATH="$(INSTALLROOT)/lib/pkgconfig";\
	export CXXFLAGS="$${CXXFLAGS} -O2 -Wall -Wextra -Wshadow -fvisibility=hidden -fdata-sections -ffunction-sections";\
	export CFLAGS="$${CFLAGS} -O2 -Wall -Wextra -Wshadow -fvisibility=hidden -fdata-sections -ffunction-sections";\
	export LDFLAGS="$${LDFLAGS} -fvisibility=hidden -fdata-sections -ffunction-sections -Wl,--gc-sections -Wl,--as-needed";\
	cd $(BUILDROOT)/e/compile && \
	$(SRCROOT)/e/configure --prefix=$(INSTALLROOT) --enable-doc \
		--enable-pam \
		--enable-device-udev \
		--enable-enotify \
		--enable-enotify \
		--enable-ibar \
		--enable-dropshadow \
		--enable-clock \
		--enable-pager \
		--enable-battery \
		--enable-temperature \
		--enable-notification \
		--enable-cpufreq \
		--enable-ibox \
		--enable-start \
		--enable-winlist \
		--enable-fileman \
		--enable-fileman-opinfo \
		--enable-wizard \
		--enable-conf \
		--enable-conf-wallpaper2 \
		--enable-conf-theme \
		--enable-conf-intl \
		--enable-msgbus \
		--enable-conf-applications \
		--enable-conf-display \
		--enable-conf-shelves \
		--enable-conf-keybindings \
		--enable-conf-edgebindings \
		--enable-conf-window-remembers \
		--enable-conf-window-manipulation \
		--enable-conf-menus \
		--enable-conf-dialogs \
		--enable-conf-performance \
		--enable-conf-paths \
		--enable-conf-interaction \
		--enable-gadman \
		--enable-mixer \
		--enable-connman \
		--enable-illume2 \
		--enable-syscon \
		--enable-everything \
		--enable-systray \
		--enable-comp \
		--enable-shot \
		--enable-backlight \
		--enable-tasks \
		--enable-conf-randr
	$(V)mkdir -p $(BUILDROOT)/e/stamps
	touch $(BUILDROOT)/e/stamps/configure
	$(V)echo "Success configuring e."

$(BUILDROOT)/e/stamps/compile: $(BUILDROOT)/e/stamps/configure e-compile
e-compile: $(BUILDROOT)/e/stamps/configure
	$(V)echo "Compiling e..."
	$(V)rm -f $(BUILDROOT)/e/stamps/compile-updated
	$(V)mkdir -p $(BUILDROOT)/e/stamps
	$(V)if make --dry-run $(MAKEOPTS) all -C $(BUILDROOT)/e/compile 2>/dev/null | grep -e 'libtool ' >/dev/null 2>/dev/null; then\
		touch $(BUILDROOT)/e/stamps/compile-updated;\
	fi
	$(V)if test -f $(BUILDROOT)/e/stamps/compile-updated; then\
		echo "make $(MAKEOPTS) all -C $(BUILDROOT)/e/compile";\
		export PATH="$(INSTALLROOT)/bin:$${PATH}";\
	export PKG_CONFIG_PATH="$(INSTALLROOT)/lib/pkgconfig";\
	export CXXFLAGS="$${CXXFLAGS} -O2 -Wall -Wextra -Wshadow -fvisibility=hidden -fdata-sections -ffunction-sections";\
	export CFLAGS="$${CFLAGS} -O2 -Wall -Wextra -Wshadow -fvisibility=hidden -fdata-sections -ffunction-sections";\
	export LDFLAGS="$${LDFLAGS} -fvisibility=hidden -fdata-sections -ffunction-sections -Wl,--gc-sections -Wl,--as-needed";\
	make $(MAKEOPTS) all -C $(BUILDROOT)/e/compile;\
	else\
		echo "e is up to date.";\
	fi
	$(V)if test ! -f $(BUILDROOT)/e/stamps/compile -o -f $(BUILDROOT)/e/stamps/compile-updated; then\
		touch $(BUILDROOT)/e/stamps/compile;\
		echo "Compile updated, needs reinstall.";\
	fi
	$(V)echo "Success compiling e."

$(BUILDROOT)/e/stamps/install: $(BUILDROOT)/e/stamps/compile e-install
e-install: $(BUILDROOT)/e/stamps/compile
	$(V)echo "Installing e..."
	$(V)if test ! -f $(BUILDROOT)/e/stamps/install -o $(BUILDROOT)/e/stamps/compile -nt $(BUILDROOT)/e/stamps/install; then\
		rm -f $(BUILDROOT)/e/stamps/install;\
		echo "make $(MAKEOPTS) install -C $(BUILDROOT)/e/compile";\
		export PATH="$(INSTALLROOT)/bin:$${PATH}";\
	export PKG_CONFIG_PATH="$(INSTALLROOT)/lib/pkgconfig";\
	export CXXFLAGS="$${CXXFLAGS} -O2 -Wall -Wextra -Wshadow -fvisibility=hidden -fdata-sections -ffunction-sections";\
	export CFLAGS="$${CFLAGS} -O2 -Wall -Wextra -Wshadow -fvisibility=hidden -fdata-sections -ffunction-sections";\
	export LDFLAGS="$${LDFLAGS} -fvisibility=hidden -fdata-sections -ffunction-sections -Wl,--gc-sections -Wl,--as-needed";\
	make $(MAKEOPTS) install -C $(BUILDROOT)/e/compile;\
		mkdir -p $(BUILDROOT)/e/stamps;\
		touch $(BUILDROOT)/e/stamps/install;\
	else\
		echo "e did not change, not need to reinstall.";\
	fi
	$(V)echo "Success installing e."

$(BUILDROOT)/e/stamps/test: $(BUILDROOT)/e/stamps/compile e-test
e-test: $(BUILDROOT)/e/stamps/compile
	$(V)mkdir -p $(BUILDROOT)/e/stamps
	touch $(BUILDROOT)/e/stamps/test
	$(V)echo 'No test target defined for e'

$(BUILDROOT)/e/stamps/doc: $(BUILDROOT)/e/stamps/compile e-doc
e-doc: $(BUILDROOT)/e/stamps/compile
	$(V)echo "Generating documentation (make doc) e..."
	$(V)rm -f $(BUILDROOT)/e/stamps/doc
	export PATH="$(INSTALLROOT)/bin:$${PATH}";\
	export PKG_CONFIG_PATH="$(INSTALLROOT)/lib/pkgconfig";\
	export CXXFLAGS="$${CXXFLAGS} -O2 -Wall -Wextra -Wshadow -fvisibility=hidden -fdata-sections -ffunction-sections";\
	export CFLAGS="$${CFLAGS} -O2 -Wall -Wextra -Wshadow -fvisibility=hidden -fdata-sections -ffunction-sections";\
	export LDFLAGS="$${LDFLAGS} -fvisibility=hidden -fdata-sections -ffunction-sections -Wl,--gc-sections -Wl,--as-needed";\
	make $(MAKEOPTS) doc -C $(BUILDROOT)/e/compile
	$(V)mkdir -p $(BUILDROOT)/e/stamps
	touch $(BUILDROOT)/e/stamps/doc
	$(V)echo "Success generating documentation (make doc) e."

$(BUILDROOT)/e/stamps/distcheck: $(BUILDROOT)/e/stamps/compile e-distcheck
e-distcheck: $(BUILDROOT)/e/stamps/compile
	$(V)echo "Checking distribution e..."
	$(V)rm -f $(BUILDROOT)/e/stamps/distcheck
	export PATH="$(INSTALLROOT)/bin:$${PATH}";\
	export PKG_CONFIG_PATH="$(INSTALLROOT)/lib/pkgconfig";\
	export CXXFLAGS="$${CXXFLAGS} -O2 -Wall -Wextra -Wshadow -fvisibility=hidden -fdata-sections -ffunction-sections";\
	export CFLAGS="$${CFLAGS} -O2 -Wall -Wextra -Wshadow -fvisibility=hidden -fdata-sections -ffunction-sections";\
	export LDFLAGS="$${LDFLAGS} -fvisibility=hidden -fdata-sections -ffunction-sections -Wl,--gc-sections -Wl,--as-needed";\
	make $(MAKEOPTS) distcheck -C $(BUILDROOT)/e/compile
	$(V)mkdir -p $(BUILDROOT)/e/stamps
	touch $(BUILDROOT)/e/stamps/distcheck
	$(V)echo "Success checking distribution e."

e-direct-users-compile:

e-all-users-compile:

########################################################################
# clouseau rules
clouseau-dependencies: $(BUILDROOT)/clouseau/stamps/dependencies edje-install elementary-install efl-install
$(BUILDROOT)/clouseau/stamps/dependencies: $(BUILDROOT)/edje/stamps/install $(BUILDROOT)/elementary/stamps/install $(BUILDROOT)/efl/stamps/install
	$(V)mkdir -p $(BUILDROOT)/clouseau/stamps
	touch $(BUILDROOT)/clouseau/stamps/dependencies

clouseau-clean:
	if test -d $(BUILDROOT)/clouseau/compile; then chmod -R u+w $(BUILDROOT)/clouseau/compile; fi
	rm -fr $(BUILDROOT)/clouseau/compile
	rm -fr $(BUILDROOT)/clouseau/stamps

$(BUILDROOT)/clouseau/stamps/autogen: $(SRCROOT)/clouseau/autogen.sh $(SRCROOT)/clouseau/configure.ac
	$(V)echo "Running 'autogen.sh' for clouseau..."
	$(V)rm -f $(BUILDROOT)/clouseau/stamps/autogen
	cd $(SRCROOT)/clouseau && NOCONFIGURE=1 ./autogen.sh
	$(V)mkdir -p $(BUILDROOT)/clouseau/stamps
	touch $(BUILDROOT)/clouseau/stamps/autogen
	$(V)echo "Success running 'autogen.sh' for clouseau."

$(BUILDROOT)/clouseau/stamps/configure: $(BUILDROOT)/clouseau/stamps/autogen $(BUILDROOT)/clouseau/stamps/dependencies
	$(V)echo "Configuring clouseau..."
	$(V)rm -f $(BUILDROOT)/clouseau/stamps/configure
	$(V)mkdir -p $(BUILDROOT)/clouseau/compile
	export PATH="$(INSTALLROOT)/bin:$${PATH}";\
	export PKG_CONFIG_PATH="$(INSTALLROOT)/lib/pkgconfig";\
	export CXXFLAGS="$${CXXFLAGS} -O2 -Wall -Wextra -Wshadow -fvisibility=hidden -fdata-sections -ffunction-sections";\
	export CFLAGS="$${CFLAGS} -O2 -Wall -Wextra -Wshadow -fvisibility=hidden -fdata-sections -ffunction-sections";\
	export LDFLAGS="$${LDFLAGS} -fvisibility=hidden -fdata-sections -ffunction-sections -Wl,--gc-sections -Wl,--as-needed";\
	cd $(BUILDROOT)/clouseau/compile && \
	$(SRCROOT)/clouseau/configure --prefix=$(INSTALLROOT) 
	$(V)mkdir -p $(BUILDROOT)/clouseau/stamps
	touch $(BUILDROOT)/clouseau/stamps/configure
	$(V)echo "Success configuring clouseau."

$(BUILDROOT)/clouseau/stamps/compile: $(BUILDROOT)/clouseau/stamps/configure clouseau-compile
clouseau-compile: $(BUILDROOT)/clouseau/stamps/configure
	$(V)echo "Compiling clouseau..."
	$(V)rm -f $(BUILDROOT)/clouseau/stamps/compile-updated
	$(V)mkdir -p $(BUILDROOT)/clouseau/stamps
	$(V)if make --dry-run $(MAKEOPTS) all -C $(BUILDROOT)/clouseau/compile 2>/dev/null | grep -e 'libtool ' >/dev/null 2>/dev/null; then\
		touch $(BUILDROOT)/clouseau/stamps/compile-updated;\
	fi
	$(V)if test -f $(BUILDROOT)/clouseau/stamps/compile-updated; then\
		echo "make $(MAKEOPTS) all -C $(BUILDROOT)/clouseau/compile";\
		export PATH="$(INSTALLROOT)/bin:$${PATH}";\
	export PKG_CONFIG_PATH="$(INSTALLROOT)/lib/pkgconfig";\
	export CXXFLAGS="$${CXXFLAGS} -O2 -Wall -Wextra -Wshadow -fvisibility=hidden -fdata-sections -ffunction-sections";\
	export CFLAGS="$${CFLAGS} -O2 -Wall -Wextra -Wshadow -fvisibility=hidden -fdata-sections -ffunction-sections";\
	export LDFLAGS="$${LDFLAGS} -fvisibility=hidden -fdata-sections -ffunction-sections -Wl,--gc-sections -Wl,--as-needed";\
	make $(MAKEOPTS) all -C $(BUILDROOT)/clouseau/compile;\
	else\
		echo "clouseau is up to date.";\
	fi
	$(V)if test ! -f $(BUILDROOT)/clouseau/stamps/compile -o -f $(BUILDROOT)/clouseau/stamps/compile-updated; then\
		touch $(BUILDROOT)/clouseau/stamps/compile;\
		echo "Compile updated, needs reinstall.";\
	fi
	$(V)echo "Success compiling clouseau."

$(BUILDROOT)/clouseau/stamps/install: $(BUILDROOT)/clouseau/stamps/compile clouseau-install
clouseau-install: $(BUILDROOT)/clouseau/stamps/compile
	$(V)echo "Installing clouseau..."
	$(V)if test ! -f $(BUILDROOT)/clouseau/stamps/install -o $(BUILDROOT)/clouseau/stamps/compile -nt $(BUILDROOT)/clouseau/stamps/install; then\
		rm -f $(BUILDROOT)/clouseau/stamps/install;\
		echo "make $(MAKEOPTS) install -C $(BUILDROOT)/clouseau/compile";\
		export PATH="$(INSTALLROOT)/bin:$${PATH}";\
	export PKG_CONFIG_PATH="$(INSTALLROOT)/lib/pkgconfig";\
	export CXXFLAGS="$${CXXFLAGS} -O2 -Wall -Wextra -Wshadow -fvisibility=hidden -fdata-sections -ffunction-sections";\
	export CFLAGS="$${CFLAGS} -O2 -Wall -Wextra -Wshadow -fvisibility=hidden -fdata-sections -ffunction-sections";\
	export LDFLAGS="$${LDFLAGS} -fvisibility=hidden -fdata-sections -ffunction-sections -Wl,--gc-sections -Wl,--as-needed";\
	make $(MAKEOPTS) install -C $(BUILDROOT)/clouseau/compile;\
		mkdir -p $(BUILDROOT)/clouseau/stamps;\
		touch $(BUILDROOT)/clouseau/stamps/install;\
	else\
		echo "clouseau did not change, not need to reinstall.";\
	fi
	$(V)echo "Success installing clouseau."

$(BUILDROOT)/clouseau/stamps/test: $(BUILDROOT)/clouseau/stamps/compile clouseau-test
clouseau-test: $(BUILDROOT)/clouseau/stamps/compile
	$(V)mkdir -p $(BUILDROOT)/clouseau/stamps
	touch $(BUILDROOT)/clouseau/stamps/test
	$(V)echo 'No test target defined for clouseau'

$(BUILDROOT)/clouseau/stamps/doc: $(BUILDROOT)/clouseau/stamps/compile clouseau-doc
clouseau-doc: $(BUILDROOT)/clouseau/stamps/compile
	$(V)mkdir -p $(BUILDROOT)/clouseau/stamps
	touch $(BUILDROOT)/clouseau/stamps/doc
	$(V)echo 'No doc target defined for clouseau'

$(BUILDROOT)/clouseau/stamps/distcheck: $(BUILDROOT)/clouseau/stamps/compile clouseau-distcheck
clouseau-distcheck: $(BUILDROOT)/clouseau/stamps/compile
	$(V)echo "Checking distribution clouseau..."
	$(V)rm -f $(BUILDROOT)/clouseau/stamps/distcheck
	export PATH="$(INSTALLROOT)/bin:$${PATH}";\
	export PKG_CONFIG_PATH="$(INSTALLROOT)/lib/pkgconfig";\
	export CXXFLAGS="$${CXXFLAGS} -O2 -Wall -Wextra -Wshadow -fvisibility=hidden -fdata-sections -ffunction-sections";\
	export CFLAGS="$${CFLAGS} -O2 -Wall -Wextra -Wshadow -fvisibility=hidden -fdata-sections -ffunction-sections";\
	export LDFLAGS="$${LDFLAGS} -fvisibility=hidden -fdata-sections -ffunction-sections -Wl,--gc-sections -Wl,--as-needed";\
	make $(MAKEOPTS) distcheck -C $(BUILDROOT)/clouseau/compile
	$(V)mkdir -p $(BUILDROOT)/clouseau/stamps
	touch $(BUILDROOT)/clouseau/stamps/distcheck
	$(V)echo "Success checking distribution clouseau."

clouseau-direct-users-compile:

clouseau-all-users-compile: