x11-common: Fix unusable serial console

The serial console port is basicly unusable in images containing X. Login works fine, but at the shell prompt only one out of N input characters (N usually between 2 and 10) gets through to the shell. dbus-launch (running as "dbus-launch --sh-syntax --exit-with-session") is also reading from /dev/console and "eating" the missing characters. As soon as I stop the Xserver ("sh /etc/init.d/xserver-nodm stop") the serial console starts wroking fine (because dbus-launch is not running any more). This patch addresses the problem. Signed-off-by: Wolfgang Denk <wd@denx.de> Signed-off-by: Richard Purdie <richard.purdie@linuxfoundation.org>
tslib: 32bit big endian support
2026-03-16 20:29:41 +01:00 · 2011-03-18 16:41:25 +00:00 · 2011-02-22 14:50:41 -08:00 · 2011-02-22 14:50:41 -08:00 · 2011-02-22 14:11:33 -08:00 · 2011-02-10 11:50:20 -08:00
5432 changed files with 3446091 additions and 446318 deletions
--- a/.gitignore
+++ b/.gitignore
@@ -0,0 +1,26 @@
+*.pyc
+*.pyo
+build/conf/local.conf
+build/conf/bblayers.conf
+build/tmp/
+build/sstate-cache
+build/pyshtables.py
+pstage/
+scripts/poky-git-proxy-socks
+sources/
+meta-darwin
+meta-maemo
+meta-extras
+meta-m2
+meta-prvt*
+poky-autobuilder*
+*.swp
+*.orig
+*.rej
+*~
+documentation/poky-ref-manual/poky-ref-manual.html
+documentation/poky-ref-manual/poky-ref-manual.pdf
+documentation/poky-ref-manual/poky-ref-manual.tgz
+documentation/poky-ref-manual/bsp-guide.html
+documentation/poky-ref-manual/bsp-guide.pdf
+
--- a/220
+++ b/220
@@ -0,0 +1,220 @@
+commit fd7a07b3a2153826bedda2ef76b9a33ab2791680
+Author: Scott Garman <scott.a.garman@intel.com>
+Date:   Fri Jan 21 14:15:05 2011 -0800
+
+    poky-extract-sdk: allow relative paths for extract-dir
+    
+    psuedo needs a full path to its pid file, so convert
+    relative extract-dir paths to full ones.
+    
+    The symptom of this bug is receiving the following error:
+    
+    pseudo: Couldn't open relative/path/to/var/pseudo/pseudo.pid: No such file or directory
+    
+    This fixes [BUGID #670]
+    
+    Signed-off-by: Scott Garman <scott.a.garman@intel.com>
+
+commit 01bc47f4d47df3276b4b6c2583bcddd834fd5050
+Author: Beth Flanagan <elizabeth.flanagan@intel.com>
+Date:   Wed Nov 3 17:20:00 2010 -0700
+
+    quilt: Fixed configure test for patch --version.
+    
+    OpenSuSE 11.3 uses GNU patch 2.6.1.81-5b68 which breaks quilt's
+    configure test for patch version.
+    
+    Signed-off-by: Beth Flanagan <elizabeth.flanagan@intel.com>
+
+commit 12a3d41a24db79ae6c0491defffcf4f4753001cf
+Author: Richard Purdie <richard.purdie@linuxfoundation.org>
+Date:   Fri Jan 14 11:57:18 2011 +0000
+
+    image.bbclass: Use the dedicated BB_WORKERCONTEXT, not bitbake internals to detect context
+    
+    Signed-off-by: Richard Purdie <richard.purdie@linuxfoundation.org>
+
+commit ce4f8356796bc797d9156ed252a4ed638a2150d5
+Author: Richard Purdie <rpurdie@linux.intel.com>
+Date:   Wed Dec 15 23:22:16 2010 +0000
+
+    scripts/poky-qemu: Improve tmp layout assumption
+    
+    If someone has changed TMPDIR in local.conf to a non-standard location, the
+    poky-qemu script currently doesn't handle this and assumes if BUILDDIR is set,
+    $BUILDDIR/tmp will exist.
+    
+    Its simple to check if this exists and if not, to ask bitbake where the
+    directory is so this patch changes the code to do that.
+    
+    Signed-off-by: Richard Purdie <rpurdie@linux.intel.com>
+
+commit 54f08d23cd7d0de6aec31f4764389ff4dab2990d
+Author: Scott Garman <scott.a.garman@intel.com>
+Date:   Tue Dec 7 20:59:06 2010 -0800
+
+    Make poky-qemu and related scripts work with arbitrary SDK locations
+    
+    * No longer assume SDK toolchains are installed in /opt/poky
+    * [BUGFIX #568] where specifying paths to both the kernel and fs
+      image caused an error due to POKY_NATIVE_SYSROOT never being
+      set, triggering failure of poky-qemu-ifup/ifdown
+    * Cosmetic improvements to usage() functions by using basename
+    
+    Signed-off-by: Scott Garman <scott.a.garman@intel.com>
+
+commit 8a3d0f375ce416ada1a5443e4a8e467504001beb
+Author: Scott Garman <scott.a.garman@intel.com>
+Date:   Fri Nov 12 16:31:13 2010 -0800
+
+    poky-qemu: Fix issues when running Yocto 0.9 release images
+    
+    This fixes two bugs with poky-qemu when it is run from a
+    standalone meta-toolchain setup.
+    
+    [BUGFIX #535] and [BUGFIX #536]
+    
+    Signed-off-by: Scott Garman <scott.a.garman@intel.com>
+
+commit 0c2003f13434c77f901a976523478d37d8aadb48
+Author: Paul Eggleton <paul.eggleton@linux.intel.com>
+Date:   Thu Dec 16 10:29:50 2010 +0000
+
+    openssl: restore -Wall flag
+    
+    The -Wall flag was unintentionally removed from the end of the CFLAG var in
+    089612794d4d8d9c79bd2a4365d6df78371f7f40 by me. This patch puts it back in.
+    
+    Signed-off-by: Paul Eggleton <paul.eggleton@linux.intel.com>
+    Signed-off-by: Richard Purdie <rpurdie@linux.intel.com>
+
+commit 6e71b0a012f0676c06b7b4788d932f320fca0b74
+Author: Joshua Lock <josh@linux.intel.com>
+Date:   Wed Dec 15 14:31:21 2010 +0000
+
+    web-webkit: fix for make 3.82
+    
+    Signed-off-by: Joshua Lock <josh@linux.intel.com>
+
+commit 4b5c1c053000d297956f08949ffde7454ee33c5d
+Author: Joshua Lock <josh@linux.intel.com>
+Date:   Wed Dec 15 13:42:15 2010 +0000
+
+    contacts: fix for make 3.82
+    
+    Signed-off-by: Joshua Lock <josh@linux.intel.com>
+
+commit 171e709ae6f4b1a7640bf393f57aa787648cdc0f
+Author: Joshua Lock <josh@linux.intel.com>
+Date:   Wed Dec 15 12:58:09 2010 +0000
+
+    dates: fix for Make 3.82
+    
+    Signed-off-by: Joshua Lock <josh@linux.intel.com>
+
+commit a8b8557e4cb34b594bb620eb276bcaf7a8e0a8e3
+Author: Joshua Lock <josh@linux.intel.com>
+Date:   Wed Dec 15 12:27:52 2010 +0000
+
+    owl-video-widget: fix Makefile for super strict make 3.82
+    
+    Signed-off-by: Joshua Lock <josh@linux.intel.com>
+
+commit 399e6b8008cb0b8cc0b75efd48dd821a6cf5a8a8
+Author: Joshua Lock <josh@linux.intel.com>
+Date:   Tue Dec 14 18:29:43 2010 +0000
+
+    libowl-av: fix for Make 3.82
+    
+    Signed-off-by: Joshua Lock <josh@linux.intel.com>
+
+commit 290280b332570ec73301f76765b1c5f2de20a9fd
+Author: Joshua Lock <josh@linux.intel.com>
+Date:   Tue Dec 14 17:56:53 2010 +0000
+
+    gst-plugins: fix for make 3.82
+    
+    Signed-off-by: Joshua Lock <josh@linux.intel.com>
+
+commit 9e11fbf9048b17526ca8160d82b69f386595c9a7
+Author: Joshua Lock <josh@linux.intel.com>
+Date:   Tue Dec 14 15:39:42 2010 +0000
+
+    gstreamer: fix to comply with make 3.82's stricter parser
+    
+    Signed-off-by: Joshua Lock <josh@linux.intel.com>
+
+commit 0f8244faba5c36c0580081c112ea27ce683af99b
+Author: Joshua Lock <josh@linux.intel.com>
+Date:   Tue Dec 14 12:49:13 2010 +0000
+
+    linux-libc-headers: fix for Make 3.82
+    
+    Fix the kernel Makefile for use with Make 3.82 by splitting mixed implicit and
+    normal rules into separate rules.
+    
+    Signed-off-by: Joshua Lock <josh@linux.intel.com>
+
+commit 0cc23a86562d0ce1e236ceb4a56a8f19d400192f
+Author: Joshua Lock <josh@linux.intel.com>
+Date:   Tue Dec 14 12:21:33 2010 +0000
+
+    busybox: additional fixes for Make 3.82
+    
+    There where still some mixed implicit and normal rules in the Busybox Makefile,
+    Update our existing make-382.patch to split these into separate rules.
+    
+    Signed-off-by: Joshua Lock <josh@linux.intel.com>
+
+commit 30c39cc97c384134661300e107d7a81f257f8034
+Author: Joshua Lock <josh@linux.intel.com>
+Date:   Fri Nov 12 16:36:54 2010 +0000
+
+    procps: fix for build against make 3.82
+    
+    Signed-off-by: Joshua Lock <josh@linux.intel.com>
+
+commit 261ca885962ba9606bcad4c5415927a79fdd7b96
+Author: Joshua Lock <josh@linux.intel.com>
+Date:   Tue Nov 9 12:18:14 2010 +0000
+
+    busybox: import upstream patch for make 3.82
+    
+    Signed-off-by: Joshua Lock <josh@linux.intel.com>
+
+commit 72ddd5c20246a5d5b1752b58a61ef75b4c39cc40
+Author: Joshua Lock <josh@linux.intel.com>
+Date:   Tue Nov 9 12:14:28 2010 +0000
+
+    eglibc: fix build of eglibc-initial for make 3.82
+    
+    Make 3.82, as shipped with Fedora 14, fixes some holes in the parser which in
+    turn breaks behaviour of some Makefiles. Most notably eglibc's.
+    
+    Signed-off-by: Joshua Lock <josh@linux.intel.com>
+
+commit 6026999e81042a7f6560f9bce04390865509b235
+Author: Paul Eggleton <paul.eggleton@intel.com>
+Date:   Fri Nov 19 15:03:32 2010 +0000
+
+    qemu: fix failure to find zlib header files during configure
+    
+    Corrects problems during configure of qemu-native due to the BUILD_CFLAGS
+    not being included when attempting to compile the test program for zlib
+    within the configure script.
+    
+    Signed-off-by: Paul Eggleton <paul.eggleton@intel.com>
+    Signed-off-by: Richard Purdie <rpurdie@linux.intel.com>
+
+commit c5ab4d56f97a0e45b124d40c9f536541be04c201
+Author: Paul Eggleton <paul.eggleton@intel.com>
+Date:   Wed Nov 17 11:37:47 2010 +0000
+
+    openssl-native: disable execstack flag to prevent problems with SELinux
+    
+    The execstack flag gets set on libcrypto.so by default which causes SELinux
+    to prevent it from being loaded on systems using SELinux, which includes
+    Fedora. This patch disables the execstack flag. (Note: Red Hat do this in
+    their openssl packaging.)
+    
+    Signed-off-by: Paul Eggleton <paul.eggleton@linux.intel.com>
--- a/5
+++ b/5
@@ -5,7 +5,10 @@ bitbake/COPYING (GPLv2)
 meta/COPYING.MIT (MIT)
 meta-extras/COPYING.MIT (MIT)

-which cover the components in those subdirectories.
+which cover the components in those subdirectories. This means all 
+metadata is MIT licensed unless otherwise stated. Source code included 
+in tree for individual recipes is under the LICENSE stated in the .bb 
+file for those software projects unless otherwise stated.

 License information for any other files is either explicitly stated 
 or defaults to GPL version 2.
--- a/70
+++ b/70
@@ -0,0 +1,70 @@
+Name: Laverne
+Version: 4.0.1
+Built from Revision: fd7a07b3a2153826bedda2ef76b9a33ab2791680
+Build Date: Jan 26 2011
+Builder: autobuilder.pokylinux.org 
+
+The Laverne 4.0.1 Release ensures you can use Poky Laverne on systems running 
+Fedora 14 and Opensuse 11.3, fixes issues with the poky-qemu script, and fixes 
+several other bugs. For the full changelog for Laverne 4.0.1 please read 
+CHANGELOG.
+
+Following are descriptions of fixes and known issues.
+
+Fixes
+------------------------
+
+    * Make 3.82, as shipped with Fedora 14, included parser bug fixes that 
+    resulted in a much stricter parser. As a result, the Makefiles could not be 
+    parsed for many of the software versions shipped with Laverne. The Makefiles
+    in the following recipes were fixed:
+
+          o eglibc
+          o busybox
+          o procps
+          o linux-libc-headers
+          o gstreamer
+          o gst-plugins
+          o libowl-av
+          o owl-video-widget
+          o dates
+          o contacts
+          o web-webkit 
+
+    * The ability to build openssl-native on a system that has SELINUX enabled 
+    was restored. (We disabled the execstack flag at compile time.) 
+
+    * A host-intrusion issue caused by a failure in QEMU to find zlib headers 
+    during configure was fixed. The issue was causing qemu-native to use the 
+    system zlib if it was present. If the system zlib was not present the build 
+    would fail. 
+
+    * Stability and usability enhancements, which included handling relative 
+    filesystem paths, were made to poky-qemu scripts. 
+
+    * The run-time remapping of package names when adding extra packages to an 
+    image via the IMAGE_INSTALL mechanism were fixed. 
+
+    * The configure test in quilt for GNU patch was fixed to that it correctly 
+    detects the version. 
+
+Known Issues
+------------------------
+
+    * The mpc3815e-rbd and routerstationpro machines were untested and not a 
+    part of the official Laverne 4.0 release. These machines are still unusable 
+    for this Laverne 4.0.1 release.
+          o mpx3815e-rdb will not boot due to a kernel/uboot issue Bug #685
+          o routerstation will not boot (by default) due to incorrect boot 
+          parameters Bug #681
+          o routerstationpro debug messages related to the ethernet driver print 
+          during boot Bug #679 
+    * Shutdown/poweroff on qemuarm does not cleanly halt the virtual machine. 
+    To workaround this issue use the reboot command. Using this command avoids 
+    a "power-cycle" and instead cleanly shuts down the VM Bug #684
+    * Two "Connection Manager" icons appear in the Sato UI. This duplication has
+    been fixed in master. Note that you can use either icon to launch the 
+    connectivity UI. Bug #683
+    * The on-screen keyboard incorrectly launches in the qemumips machine. This 
+    issue is due to a mis-configured formfactor file Bug #682 
+
--- a/79
+++ b/79
@@ -1,70 +1,15 @@
-Introduction
-==
+Poky
+====

-'Poky' is a combined cross build system and linux distribution based
-upon OpenEmbedded. It features support for building X11/Matchbox/GTK
-based filesystem images for various embedded devices and boards.
+Poky platform builder is a combined cross build system and development 
+environment. It features support for building X11/Matchbox/GTK based 
+filesystem images for various embedded devices and boards. It also 
+supports cross-architecture application development using QEMU emulation
+and a standalone toolchain and SDK with IDE integration.

+Poky has an extensive handbook, the source of which is contained in
+the handbook directory. For compiled HTML or pdf versions of this, 
+see the Poky website http://pokylinux.org.

-Required Packages
-===
-
-Running Poky on Debian based distributions requires the following
-extra packages be installed;
-
-build-essential
-diffstat
-texinfo
-texi2html
-cvs
-subversion
-gawk
-bochsbios (to run qemux86 images)
-
-You also need to install the qemu from http://debian.o-hand.com/. A
-poky-depends deb is also available from this source which will install 
-all the dependencies mentioned above for you.
-
-Alternatively poky can build qemu itself, but for this you need the
-following packages installed;
-
-gcc-3.4
-libsdl1.2-dev
-zlib1g-dev
-
-You will also need to comment out ASSUME_PROVIDED += "qemu-native"' in  
-build/conf/local.conf.
-
-Building under other distro's such as Fedora is known to work. Use the above
-package names as a guide for dependencies.
-
-Building An Image
-===
-
-Simply run;
-
-% source poky-init-build-env
-% bitbake poky-image-sato
-
-This will result in an ext2 image and kernel for qemu arm (see scripts dir).
-
-To build for other machine types see MACHINE in build/conf/local.conf
-
-Other image targets such as poky-image-sdk or poky-image-minimal are available, 
-see meta/packages/images/*.
-
-Notes:
-===
-
-Useful Links;
-
-OpenedHand
-http://openedhand.com
-
-Poky Homepage
-http://projects.o-hand.com/poky
-
-OE Homepage and wiki
-http://openembedded.org
- 
-                                         Copyright (C) 2006-2007 OpenedHand Ltd.
+Additional information on the specifics of hardware that Poky supports
+is available in README.hardware.
--- a/README.commands
+++ b/README.commands
@@ -1,106 +0,0 @@
-                         Using Poky - Poky Commands
-                         ==========================
-
-Bitbake
-=======
-
-Bitbake is the tool at the heart of poky and is responsible for parsing the 
-metadata, generating a list of tasks from it and then executing them. To see a 
-list of the options it supports look at "bitbake --help".
-
-The most common usage is "bitbake <packagename>" where <packagename> is the name
-of the package you wish to build. This often equates to the first part of a .bb 
-filename so to run the matchbox-desktop_1.2.3.bb file, you might type "bitbake
-matchbox-desktop. Several different versions of matchbox-desktop might exist
-and bitbake will choose the one selected by the distribution configuration.
-Bitbake will also try to execute any dependent tasks first so before building
-matchbox-desktop it would build a cross compiler and glibc if not already built.
-
-
-Bitbake - Package Tasks
-=======================
-
-Any given package consists of a set of tasks, in most cases the series is fetch, 
-unpack, patch, configure, compile, install, package, package_write and build. 
-The default task is "build" and any tasks this depends on are built first hence 
-the standard bitbake behaviour. There are some tasks such as devshell which are 
-not part of the default build chain. If you wish to run such a task you can use 
-the "-c" option to bitbake e.g. "bitbake matchbox-desktop -c devshell".
-
-If you wish to rerun a task you can use the force option "-f". A typical usage 
-case might look like:
-
-% bitbake matchbox-desktop
-[change some source in the WORKDIR for example]
-% bitbake matchbox-desktop -c compile -f
-% bitbake matchbox-desktop
-
-which would build matchbox-desktop, then recompile it. The final command reruns 
-all tasks after the compile (basically the packaging tasks) since bitbake will 
-notice the the compile has been rerun and hence the other tasks also need to run 
-again.
-
-You can view a list of tasks in a given package by running the listtasks task
-e.g. "bitbake matchbox-desktop -c listtasks".
-
-
-Bitbake - Dependency Graphs
-===========================
-
-Sometimes it can be hard to see why bitbake wants to build some other packages
-before a given package you've specified. "bitbake matchbox-desktop -g" will 
-create a task-depends.dot file in the current directory. This shows which 
-packages and tasks depend on which other packages and tasks and it useful for 
-debugging purposes.
-
-
-Bitbake - Advanced Usage
-========================
-
-Debug output from bitbake can be seen with the "-D" option and can sometimes 
-give more information about what bitbake is doing and/or why. Each -D options 
-increases the logging level, the most common usage being "-DDD".
-
-If you really want to build a specific .bb file, you can use the form "bitbake
-b somepath/somefile.bb". Note that this will not check the dependencies so this
-option should only be used when you know the dependencies already exist. You can
-specify fragments of the filename and bitbake will see if it can find a unique 
-match.
-
-The -e option will dump the resulting environment for either the configuration 
-(no package specified) or for a specific package when specified with the -b 
-option.
-
-The -k option will cause bitbake to try and continue even if a task fails. It 
-can be useful for world or unattended builds.
-
-The -s option lists all the versions of packages that bitbake will use.
-
-
-Bitbake - More Information
-==========================
-
-See the bitbake user manual at: http://bitbake.berlios.de/manual/
-
-QEMU
-====
-
-Running images built by poky under qemu is possible within the poky environment
-through the "runqemu" command. It has the form:
-
-runqemu MACHINE IMAGETYPE ZIMAGE IMAGEFILE
-
-where:
-
-MACHINE - the machine to emulate (qemux86, qemuarm, spitz, akita)
-IMAGETYPE - the type of image to use (nfs or ext2)
-ZIMAGE - location of the kernel binary to use
-IMAGEFILE - location of the image file to use
-(common options are in brackets)
-
-MACHINE is mandatory, the others are optional.
-
-This assumes a suitable qemu binary is available with support for a given 
-machine. For further information see scripts/poky-qemu.README.
-
-                                         Copyright (C) 2006-2007 OpenedHand Ltd.
--- a/README.hardware
+++ b/README.hardware
@@ -0,0 +1,436 @@
+                     Poky Hardware Reference Guide
+                     =============================
+
+This file gives details about using Poky with different hardware reference
+boards and consumer devices. A full list of target machines can be found by 
+looking in the meta/conf/machine/ directory. If in doubt about using Poky with 
+your hardware, consult the documentation for your board/device. To discuss 
+support for further hardware reference boards/devices please contact OpenedHand.
+
+QEMU Emulation Images (qemuarm and qemux86)
+===========================================
+
+To simplify development Poky supports building images to work with the QEMU
+emulator in system emulation mode. Two architectures are currently supported,
+ARM (via qemuarm) and x86 (via qemux86). Use of the QEMU images is covered
+in the Poky Handbook.
+
+Hardware Reference Boards
+=========================
+
+The following boards are supported by Poky:
+
+  * Compulab CM-X270 (cm-x270)
+  * Compulab EM-X270 (em-x270)
+  * FreeScale iMX31ADS (mx31ads)
+  * Marvell PXA3xx Zylonite (zylonite)
+  * Logic iMX31 Lite Kit (mx31litekit)
+  * Phytec phyCORE-iMX31 (mx31phy)
+
+For more information see board's section below. The Poky MACHINE setting
+corresponding to the board is given in brackets.
+
+Consumer Devices
+================
+
+The following consumer devices are supported by Poky:
+
+  * FIC Neo1973 GTA01 smartphone (fic-gta01)
+  * HTC Universal (htcuniversal)
+  * Nokia 770/N800/N810 Internet Tablets (nokia770 and nokia800)
+  * Sharp Zaurus SL-C7x0 series (c7x0)
+  * Sharp Zaurus SL-C1000 (akita)
+  * Sharp Zaurus SL-C3x00 series (spitz)
+
+For more information see board's section below. The Poky MACHINE setting
+corresponding to the board is given in brackets.
+
+Poky Boot CD (bootcdx86)
+========================
+
+The Poky boot CD iso images are designed as a demonstration of the Poky 
+environment and to show the versatile image formats Poky can generate. It will
+run on Pentium2 or greater PC style computers. The iso image can be 
+burnt to CD and then booted from.
+
+
+                          Hardware Reference Boards
+                          =========================
+
+Compulab CM-X270 (cm-x270)
+==========================
+
+The bootloader on this board doesn't support writing jffs2 images directly to 
+NAND and normally uses a proprietary kernel flash driver. To allow the use of
+jffs2 images, a two stage updating procedure is needed. Firstly, an initramfs
+is booted which contains mtd utilities and this is then used to write the main
+filesystem. 
+
+It is assumed the board is connected to a network where a TFTP server is 
+available and that a serial terminal is available to communicate with the 
+bootloader (38400, 8N1). If a DHCP server is available the device will use it
+to obtain an IP address. If not, run:
+
+  ARMmon > setip dhcp off
+  ARMmon > setip ip 192.168.1.203
+  ARMmon > setip mask 255.255.255.0
+
+To reflash the kernel:
+
+  ARMmon > download kernel tftp zimage 192.168.1.202
+  ARMmon > flash kernel
+
+where zimage is the name of the kernel on the TFTP server and its IP address is 
+192.168.1.202. The names of the files must be all lowercase.
+
+To reflash the initrd/initramfs:
+
+  ARMmon > download ramdisk tftp diskimage 192.168.1.202
+  ARMmon > flash ramdisk
+
+where diskimage is the name of the initramfs image (a cpio.gz file).
+
+To boot the initramfs:
+
+  ARMmon > ramdisk on
+  ARMmon > bootos "console=ttyS0,38400 rdinit=/sbin/init"
+
+To reflash the main image login to the system as user "root", then run:
+
+  # ifconfig eth0 192.168.1.203
+  # tftp -g -r mainimage 192.168.1.202
+  # flash_eraseall /dev/mtd1
+  # nandwrite /dev/mtd1 mainimage
+
+which configures the network interface with the IP address 192.168.1.203,
+downloads the "mainimage" file from the TFTP server at 192.168.1.202, erases
+the flash and then writes the new image to the flash.
+
+The main image can then be booted with:
+
+  ARMmon > bootos "console=ttyS0,38400 root=/dev/mtdblock1 rootfstype=jffs2"
+
+Note that the initramfs image is built by poky in a slightly different mode to
+normal since it uses uclibc. To generate this use a command like:
+
+IMAGE_FSTYPES=cpio.gz MACHINE=cm-x270 POKYLIBC=uclibc bitbake poky-image-minimal-mtdutils
+
+
+Compulab EM-X270 (em-x270)
+==========================
+
+Fetch the "Linux - kernel and run-time image (Angstrom)" ZIP file from the
+Compulab website. Inside the images directory of this ZIP file is another ZIP
+file called 'LiveDisk.zip'. Extract this over a cleanly formatted vfat USB flash
+drive. Replace the 'em_x270.img' file with the 'updater-em-x270.ext2' file.
+
+Insert this USB disk into the supplied adapter and connect this to the
+board. Whilst holding down the the suspend button press the reset button. The
+board will now boot off the USB key and into a version of Angstrom. On the
+desktop is an icon labelled "Updater". Run this program to launch the updater
+that will flash the Poky kernel and rootfs to the board.
+
+
+FreeScale iMX31ADS (mx31ads)
+===========================
+
+The correct serial port is the top-most female connector to the right of the
+ethernet socket.
+
+For uploading data to RedBoot we are going to use tftp. In this example we
+assume that the tftpserver is on 192.168.9.1 and the board is on192.168.9.2. 
+
+To set the IP address, run:
+
+  ip_address -l 192.168.9.2/24 -h 192.168.9.1
+
+To download a kernel called "zimage" from the TFTP server, run:
+
+  load -r -b 0x100000 zimage
+
+To write the kernel to flash run:
+
+  fis create kernel
+
+To download a rootfs jffs2 image "rootfs" from the TFTP server, run:
+
+  load -r -b 0x100000 rootfs
+
+To write the root filesystem  to flash run:
+
+  fis create root
+
+To load and boot a kernel and rootfs from flash:
+
+  fis load kernel
+  exec -b 0x100000 -l 0x200000 -c "noinitrd console=ttymxc0,115200 root=/dev/mtdblock2 rootfstype=jffs2 init=linuxrc ip=none"
+
+To load and boot a kernel from a TFTP server with the rootfs over NFS:
+
+  load -r -b 0x100000 zimage
+  exec -b 0x100000 -l 0x200000 -c "noinitrd console=ttymxc0,115200 root=/dev/nfs nfsroot=192.168.9.1:/mnt/nfsmx31 rw ip=192.168.9.2::192.168.9.1:255.255.255.0"
+
+The instructions above are for using the (default) NOR flash on the board,
+there is also 128M of NAND flash. It is possible to install Poky to the NAND 
+flash which gives more space for the rootfs and instructions for using this are
+given below. To switch to the NAND flash:
+
+  factive NAND
+
+This will then restart RedBoot using the NAND rather than the NOR. If you
+have not used the NAND before then it is unlikely that there will be a
+partition table yet. You can get the list of partitions with 'fis list'.
+
+If this shows no partitions then you can create them with:
+
+  fis init
+
+The output of 'fis list' should now show:
+
+Name              FLASH addr  Mem addr    Length      Entry point
+RedBoot           0xE0000000  0xE0000000  0x00040000  0x00000000
+FIS directory     0xE7FF4000  0xE7FF4000  0x00003000  0x00000000
+RedBoot config    0xE7FF7000  0xE7FF7000  0x00001000  0x00000000
+
+Partitions for the kernel and rootfs need to be created:
+
+fis create -l 0x1A0000 -e 0x00100000 kernel
+fis create -l 0x5000000 -e 0x00100000 root
+
+You may now use the instructions above for flashing. However it is important
+to note that the erase block size for the NAND is different to the NOR so the
+JFFS erase size will need to be changed to 0x4000. Stardard images are built
+for NOR and you will need to build custom images for NAND.
+
+You will also need to update the kernel command line to use the correct root
+filesystem. This should be '/dev/mtdblock7' if you adhere to the partitioning
+scheme shown above. If this fails then you can doublecheck against the output
+from the kernel when it evaluates the available mtd partitions.
+
+
+Marvell PXA3xx Zylonite (zylonite)
+==================================
+
+These instructions assume the Zylonite is connected to a machine running a TFTP 
+server at address 192.168.123.5 and that a serial link (38400 8N1) is available 
+to access the blob bootloader. The kernel is on the TFTP server as 
+"zylonite-kernel" and the root filesystem jffs2 file is "zylonite-rootfs" and 
+the images are to be saved in NAND flash.
+
+The following commands setup blob:
+
+  blob> setip client 192.168.123.4
+  blob> setip server 192.168.123.5
+
+To flash the kernel:
+
+  blob> tftp zylonite-kernel
+  blob> nandwrite -j 0x80800000 0x60000 0x200000
+
+To flash the rootfs:
+
+  blob> tftp zylonite-rootfs
+  blob> nanderase -j 0x260000 0x5000000
+  blob> nandwrite -j 0x80800000 0x260000 <length>
+
+(where <length> is the rootfs size which will be printed by the tftp step)
+
+To boot the board:
+
+  blob> nkernel
+  blob> boot
+
+
+Logic iMX31 Lite Kit (mx31litekit)
+===============================
+
+The easiest method to boot this board is to take an MMC/SD card and format 
+the first partition as ext2, then extract the poky image onto this as root. 
+Assuming the board is network connected, a TFTP server is available at 
+192.168.1.33 and a serial terminal is available (115200 8N1), the following 
+commands will boot a kernel called "mx31kern" from the TFTP server:
+
+  losh> ifconfig sm0 192.168.1.203 255.255.255.0 192.168.1.33
+  losh> load raw 0x80100000 0x200000 /tftp/192.168.1.33:mx31kern
+  losh> exec 0x80100000 - 
+
+
+Phytec phyCORE-iMX31 (mx31phy)
+==============================
+
+Support for this board is currently being developed. Experimental jffs2 
+images and a suitable kernel are available and are known to work with the
+board.
+
+
+                             Consumer Devices
+                             ================
+
+FIC Neo1973 GTA01 smartphone (fic-gta01)
+========================================
+
+To install Poky on a GTA01 smartphone you will need "dfu-util" tool
+which you can build with "bitbake dfu-util-native" command.
+
+Flashing requires these steps:
+
+  1. Power down the device.
+  2. Connect the device to the host machine via USB.
+  3. Hold AUX key and press Power key. There should be a bootmenu
+     on screen.
+  4. Run "dfu-util -l" to check if the phone is visible on the USB bus. 
+     The output should look like this:
+
+     dfu-util - (C) 2007 by OpenMoko Inc.
+     This program is Free Software and has ABSOLUTELY NO WARRANTY
+
+     Found Runtime: [0x1457:0x5119] devnum=19, cfg=0, intf=2, alt=0, name="USB Device Firmware Upgrade"
+
+  5. Flash the kernel with "dfu-util -a kernel -D uImage-2.6.21.6-moko11-r2-fic-gta01.bin"
+  6. Flash rootfs with "dfu-util -a rootfs -D <image>", where <image> is the
+     jffs2 image file to use as the root filesystem 
+     (e.g. ./tmp/deploy/images/poky-image-sato-fic-gta01.jffs2) 
+
+
+HTC Universal (htcuniversal)
+============================
+
+Note: HTC Universal support is highly experimental.
+
+On the HTC Universal, entirely replacing the Windows installation is not 
+supported, instead Poky is booted from an MMC/SD card from Windows. Once Poky
+has booted, Windows is no longer in memory or active but when power is removed,
+the user will be returned to windows and will need to return to Linux from 
+there.
+
+Once an MMC/SD card is available it is suggested its split into two partitions,
+one for a program called HaRET which lets you boot Linux from within Windows
+and the second for the rootfs. The HaRET partition should be the first partition
+on the card and be vfat formatted. It doesn't need to be large, just enough for
+HaRET and a kernel (say 5MB max). The rootfs should be ext2 and is usually the 
+second partition. The first partition should be vfat so Windows recognises it 
+as if it doesn't, it has been known to reformat cards.
+
+On the first partition you need three files:
+
+  * a HaRET binary (version 0.5.1 works well and a working version 
+    should be part of the last Poky release)
+  * a kernel renamed to "zImage"
+  * a default.txt which contains:
+
+set kernel "zImage"
+set mtype "855"
+set cmdline "root=/dev/mmcblk0p2 rw console=ttyS0,115200n8 console=tty0 rootdelay=5 fbcon=rotate:1"
+boot2
+
+On the second parition the root file system is extracted as root. A different
+partition layout or other kernel options can be changed in the default.txt file.
+
+When inserted into the device, Windows should see the card and let you browse
+its contents using File Explorer. Running the HaRET binary will present a dialog
+box (maybe after messages warning about running unsigned binaries) where you 
+select OK and you should then see Poky boot. Kernel messages can be seen by 
+adding psplash=false to the kernel commandline.
+
+
+Nokia 770/N800/N810 Internet Tablets (nokia770 and nokia800)
+============================================================
+
+Note: Nokia tablet support is highly experimental.
+
+The Nokia internet tablet devices are OMAP based tablet formfactor devices 
+with large screens (800x480), wifi and touchscreen.
+
+To flash images to these devices you need the "flasher" utility which can be 
+downloaded from the http://tablets-dev.nokia.com/d3.php?f=flasher-3.0. This 
+utility needs to be run as root and the usb filesystem needs to be mounted 
+although most distributions will have done this for you. Once you have this 
+follow these steps:
+
+  1. Power down the device.
+  2. Connect the device to the host machine via USB 
+     (connecting power to the device doesn't hurt either).
+  3. Run "flasher -i"
+  4. Power on the device.
+  5. The program should give an indication it's found 
+     a tablet device. If not, recheck the cables, make sure you're 
+     root and usbfs/usbdevfs is mounted.
+  6. Run "flasher -r <image> -k <kernel> -f", where <image> is the
+     jffs2 image file to use as the root filesystem 
+     (e.g. ./tmp/deploy/images/poky-image-sato-nokia800.jffs2) 
+     and <kernel> is the kernel to use 
+     (e.g. ./tmp/deploy/images/zImage-nokia800.bin).
+  7. Run "flasher -R" to reboot the device.
+  8. The device should boot into Poky.
+
+The nokia800 images and kernel will run on both the N800 and N810.
+
+
+Sharp Zaurus SL-C7x0 series (c7x0)
+==================================
+
+The Sharp Zaurus c7x0 series (SL-C700, SL-C750, SL-C760, SL-C860, SL-7500)
+are PXA25x based handheld PDAs with VGA screens. To install Poky images on
+these devices follow these steps:
+
+  1. Obtain an SD/MMC or CF card with a vfat or ext2 filesystem.
+  2. Copy a jffs2 image file (e.g. poky-image-sato-c7x0.jffs2) onto the
+     card as "initrd.bin":
+
+     $ cp ./tmp/deploy/images/poky-image-sato-c7x0.jffs2 /path/to/my-cf-card/initrd.bin
+
+  3. Copy an Linux kernel file (zImage-c7x0.bin) onto the card as 
+     "zImage.bin":
+
+     $ cp ./tmp/deploy/images/zImage-c7x0.bin /path/to/my-cf-card/zImage.bin
+
+  4. Copy an updater script (updater.sh.c7x0) onto the card
+     as "updater.sh":
+
+     $ cp ./tmp/deploy/images/updater.sh.c7x0 /path/to/my-cf-card/updater.sh
+
+  5. Power down the Zaurus.
+  6. Hold "OK" key and power on the device. An update menu should appear 
+     (in Japanese).
+  7. Choose "Update" (item 4).
+  8. The next screen will ask for the source, choose the appropriate 
+     card (CF or SD).
+  9. Make sure AC power is connected.
+  10. The next screen asks for confirmation, choose "Yes" (the left button).
+  11. The update process will start, flash the files on the card onto 
+      the device and the device will then reboot into Poky.
+
+
+Sharp Zaurus SL-C1000 (akita)
+=============================
+
+The Sharp Zaurus SL-C1000 is a PXA270 based device otherwise similar to the 
+c7x0. To install Poky images on this device follow the instructions for 
+the c7x0 but replace "c7x0" with "akita" where appropriate.
+
+
+Sharp Zaurus SL-C3x00 series (spitz)
+====================================
+
+The Sharp Zaurus SL-C3x00 devices are PXA270 based devices similar
+to akita but with an internal microdrive. The installation procedure 
+assumes a standard microdrive based device where the root (first) 
+partition has been enlarged to fit the image (at least 100MB, 
+400MB for the SDK).
+
+The procedure is the same as for the c7x0 and akita models with the 
+following differences:
+
+ 1. Instead of a jffs2 image you need to copy a compressed tarball of the 
+    root fileystem (e.g. poky-image-sato-spitz.tar.gz) onto the
+    card as "hdimage1.tgz":
+
+    $ cp ./tmp/deploy/images/poky-image-sato-spitz.tar.gz /path/to/my-cf-card/hdimage1.tgz
+
+ 2. You additionally need to copy a special tar utility  (gnu-tar) onto 
+    the card as "gnu-tar":
+
+    $ cp ./tmp/deploy/images/gnu-tar /path/to/my-cf-card/gnu-tar
+
+
+
--- a/README.host.sdk
+++ b/README.host.sdk
@@ -1,51 +0,0 @@
-Using Poky generated host SDK
-=============================
-
-How to build host SDK
-====
-
-You need to setup Poky and then run one command:
-
-$ bitbake meta-toolchain
-
-Result would be tarball in tmp/deploy/sdk/ with everything needed to build for
-your target device. Unpack this in / directory - toolchain will reside in
-/usr/local/poky/arm/ dir.
-
-Usage of SDK
-=====
-
-First add toolchain into PATH:
-
-$ export PATH=/usr/local/poky/arm/bin/:$PATH
-
-Compiler is 'arm-poky-linux-gnueabi-gcc'. Building 'helloworld' example is
-simple:
-
-$ arm-poky-linux-gnueabi-gcc hello.c -o hello
-$ file hello
-hello: ELF 32-bit LSB executable, ARM, version 1 (SYSV), for GNU/Linux 2.6.14, dynamically linked (uses shared libs), not stripped
-
-Autotools and SDK
-======
-
-'Configure' scripts allow to specify Host, Target, Build architecture. To build
-with Poky SDK you need to specify:
-
-./configure --target=arm-poky-linux-gnueabi --host=arm-poky-linux-gnueabi
-
-
-Using packages from Poky
-========
-
-During development it is often situation that we want to use some libraries
-which are available in Poky build. Their packages need to be unpacked to
-/usr/local/poky/arm/arm-poky-linux-gnueabi/ directory.
-
-For example to add libiw (from wireless-tools package) you need to unpack two
-packages:
-
-libiw29_29-pre20-r0_armv5te.ipk
-libiw-dev_29-pre20-r0_armv5te.ipk
-
-                                         Copyright (C) 2006-2007 OpenedHand Ltd.
--- a/README.structure
+++ b/README.structure
@@ -1,214 +0,0 @@
-                 A walk through the poky directory tree
-                 ======================================
-
-Poky consists of several components and understanding what these are and where 
-they each live is one of the keys to using it.
-
-Top level core components
-=========================
-
-
-bitbake/
-
-A copy of bitbake is included within poky for ease of use and resides here. 
-This should usually be the same as a standard bitbake release from the bitbake 
-project. Bitbake is a metadata interpreter and is responsible for reading the 
-poky metadata and running the tasks it defines. Failures are usually from the
-metadata and not bitbake itself and most users don't need to worry about 
-bitbake. bitbake/bin is placed into the PATH environmental variable so bitbake 
-can be found.
-
-build/
-
-This directory contains user configuration files and the output from Poky is 
-also placed here.
-
-meta/
-
-The core metadata - this is the key part of poky. Within this directory there 
-are definitions of the machines, the poky distribution and the packages that 
-make up a given system.
-
-meta-extras/
-
-Similar to meta containing some extra package files not included in standard 
-poky, disabled by default and hence not supported as part of poky.
-
-scripts/
-
-Various integration scripts which implement extra functionality in the poky 
-environment for example the qemu scripts. This directory is appended to the 
-PATH environmental variable.
-
-sources/
-
-Whilst not part of a checkout, poky will create this directory as part of any 
-build. Any downloads are placed in this directory (as specified by the
-DL_DIR variable). This directory can be shared between poky builds to save 
-downloading files multiple times. SCM checkouts are also stored here as e.g.
-sources/svn/, sources/cvs/ or sources/git/ and the sources directory may contain 
-archives of checkouts for various revisions or dates.
-
-Its worth noting that bitbake creates .md5 stamp files for downloads. It uses 
-these to mark downloads as complete as well as for checksum and access 
-accounting purposes. If you add a file manually to the directory, you need to
-touch the corresponding .md5 file too.
-
-poky-init-build-env
-
-This script is used to setup the poky build environment. Sourcing this file in
-a shell makes changes to PATH and sets other core bitbake variables based on the
-current working directory. You need to use this before running poky commands.
-Internally it uses scripts within the scripts/ directory to do the bulk of the 
-work.
-
-
-The Build Directory
-===================
-
-conf/local.conf
-
-This file contains all the local user configuration of poky. If it isn't 
-present, its created from local.conf.sample. That file contains documentation
-on the various standard options which can be configured there although any 
-standard conf file variable can be also be set here and usually overrides any
-variable set elsewhere within poky.
-
-Edit this file to set the MACHINE you want to build for, which package types you
-which to use (PACKAGE_CLASSES) or where downloaded files should go (DL_DIR) for 
-exmaple.
-
-tmp/
-
-This is created by bitbake if it doesn't exist and is where all the poky output
-is placed. To clean poky and start a build from scratch (other than downloads), 
-you can wipe this directory. tmp has some important subcomponents detailed 
-below.
-
-tmp/cache/
-
-When bitbake parses the metadata it creates a cache file of the result which can
-be used when subsequently running the command. These are stored here, usually on 
-a per machine basis.
-
-tmp/cross/
-
-The cross compiler when generated is placed into this directory and those
-beneath it.
-
-tmp/deploy/
-
-Any 'end result' output from poky is placed under here.
-
-tmp/deploy/deb/
-
-Any .deb packages emitted by poky are placed here, sorted into feeds for 
-different architecture types.
-
-tmp/deploy/images/
-
-Complete filesystem images are placed here. If you want to flash the resulting 
-image from a build onto a device, look here for them.
-
-tmp/deploy/ipk/
-
-Any resulting .ipk packages emitted by poky are placed here.
-
-tmp/rootfs/
-
-This is a temporary scratch area used when creating filesystem images. It is run
-under fakeroot and is not useful once that fakeroot session has ended as 
-information is lost. It is left around since it is still useful in debugging 
-image creation problems.
-
-tmp/staging/
-
-Any package needing to share output with other packages does so within staging.
-This means it contains any shared header files and any shared libraries amongst
-other data. It is subdivided by architecture so multiple builds can run within
-the one build directory.
-
-tmp/stamps/
-
-This is used by bitbake for accounting purposes to keep track of which tasks 
-have been run and when. It is also subdivided by architecture. The files are 
-empty and the important information is the filenames and timestamps.
-
-tmp/work/
-
-Each package build by bitbake is worked on its own work directory. Here, the 
-source is unpacked, patched, configured, compiled etc. It is subdivided by 
-architecture.
-
-It is worth considering the structure of a typical work directory. An example is
-the linux-rp kernel, version 2.6.20 r7 on the machine spitz built within poky
-which would result in a work directory of 
-"tmp/work/spitz-poky-linux-gnueabi/linux-rp-2.6.20-r7", referred to as WORKDIR.
-
-Within this, the source is unpacked to linux-2.6.20 and then patched by quilt
-hence the existence of the standard quilt directories linux-2.6.20/patches and 
-linux-2.6.20/.pc. Within the linux-2.6.20 directory, standard quilt commands 
-can be used.
-
-There are other directories generated within WORKDIR. The most important/useful 
-is WORKDIR/temp which has log files for each task (log.do_*.pid) and the scripts
-bitbake runs for each task (run.do_*.pid). WORKDIR/image is where "make install"
-places its output which is then split into subpackages within WORKDIR/install.
-
-
-The Metadata
-============
-
-As mentioned previously, this is the core of poky. It has several important 
-subdivisions:
-
-meta/classes/
-
-Contains the *.bbclass files. Class files are used to abstract common code 
-allowing it to be reused by multiple packages. The base.bbclass file is 
-inherited by every package. Examples of other important classes are 
-autotools.bbclass which in theory allows any "autotooled" package to work with 
-poky with minimal effort or kernel.bbclass which contains common code and 
-functions for working with the linux kernel. Functions like image generation or 
-packaging also have their specific class files (image.bbclass, rootfs_*.bbclass 
-and package*.bbclass).
-
-meta/conf/
-
-This is the core set of configuration files which start from bitbake.conf and 
-from which all other configuration files are included (see the includes at the 
-end of the file, even local.conf is loaded from there!). Whilst bitbake.conf 
-sets up the defaults, often these can be overridden by user (local.conf),
-machine or distribution configuration files.
-
-meta/conf/machine/
-
-Contains all the machine configuration files. If you set MACHINE="spitz", the 
-end result is poky looking for a spitz.conf file in this directory. The includes
-directory contains various data common to multiple machines. If you want to add
-support for a new machine to poky, this is the directory to look in.
-
-meta/conf/distro/
-
-Any distribution specific configuration is controlled from here. OpenEmbedded 
-supports multiple distributions of which poky is one. Poky only contains the 
-poky distribution so poky.conf is the main file here.  This includes the 
-versions and SRCDATES for applications which are configured here. An example of 
-an alternative configuration is poky-bleeding.conf although this mainly inherits
-its configuration from poky itself.
-
-packages/
-
-Each application (package) poky can build has an associated .bb file which are 
-all stored under this directory. Poky finds them through the BBFILES variable 
-which defaults to packages/*/*.bb. Adding a new piece of software to poky 
-consists of adding the appropriate .bb file. The .bb files from OpenEmbedded
-upstream are usually compatible although they are not supported.
-
-site/
-
-Certain autoconf test results cannot be determined when cross compiling since it 
-can't run tests on a live system. This directory therefore contains a list of 
-cached results for various architectures which is passed to autoconf. 
-
-                                         Copyright (C) 2006-2007 OpenedHand Ltd.
--- a/bitbake/AUTHORS
+++ b/bitbake/AUTHORS
@@ -2,7 +2,7 @@ Tim Ansell <mithro@mithis.net>
 Phil Blundell <pb@handhelds.org>
 Seb Frankengul <seb@frankengul.org>
 Holger Freyther <zecke@handhelds.org>
-Marcin Juszkiewicz <hrw@hrw.one.pl>
+Marcin Juszkiewicz <marcin@juszkiewicz.com.pl>
 Chris Larson <kergoth@handhelds.org>
 Ulrich Luckas <luckas@musoft.de>
 Mickey Lauer <mickey@Vanille.de>
--- a/bitbake/ChangeLog
+++ b/bitbake/ChangeLog
@@ -1,24 +1,183 @@
-Changes in Bitbake 1.8.x:
-	- Correctly redirect stdin when forking
-	- If parsing errors are found, exit, too many users miss the errors
-	- Remove supriours PREFERRED_PROVIDER warnings
-	- Start to fix path quoting
-
-Changes in Bitbake 1.8.4:
+Changes in Bitbake 1.9.x:
+	- Add PE (Package Epoch) support from Philipp Zabel (pH5)
+	- Treat python functions the same as shell functions for logging
+	- Use TMPDIR/anonfunc as a __anonfunc temp directory (T)
+	- Catch truncated cache file errors
+	- Allow operations other than assignment on flag variables
+	- Add code to handle inter-task dependencies
+	- Fix cache errors when generation dotGraphs
 	- Make sure __inherit_cache is updated before calling include() (from Michael Krelin)
 	- Fix bug when target was in ASSUME_PROVIDED (#2236)
 	- Raise ParseError for filenames with multiple underscores instead of infinitely looping (#2062)
 	- Fix invalid regexp in BBMASK error handling (missing import) (#1124)
-	- Don't run build sanity checks on incomplete builds
 	- Promote certain warnings from debug to note 2 level
 	- Update manual
-
-Changes in Bitbake 1.8.2:
-	- Catch truncated cache file errors
-	- Add PE (Package Epoch) support from Philipp Zabel (pH5)
-	- Add code to handle inter-task dependencies
-	- Allow operations other than assignment on flag variables
-	- Fix cache errors when generation dotGraphs
+	- Correctly redirect stdin when forking
+	- If parsing errors are found, exit, too many users miss the errors
+	- Remove supriours PREFERRED_PROVIDER warnings
+	- svn fetcher: Add _buildsvncommand function
+	- Improve certain error messages
+	- Rewrite svn fetcher to make adding extra operations easier 
+	  as part of future SRCDATE="now" fixes
+	  (requires new FETCHCMD_svn definition in bitbake.conf)
+	- Change SVNDIR layout to be more unique (fixes #2644 and #2624)
+	- Add ConfigParsed Event after configuration parsing is complete
+	- Add SRCREV support for svn fetcher
+	- data.emit_var() - only call getVar if we need the variable
+	- Stop generating the A variable (seems to be legacy code)
+	- Make sure intertask depends get processed correcting in recursive depends
+	- Add pn-PN to overrides when evaluating PREFERRED_VERSION
+	- Improve the progress indicator by skipping tasks that have 
+	  already run before starting the build rather than during it
+	- Add profiling option (-P)
+	- Add BB_SRCREV_POLICY variable (clear or cache) to control SRCREV cache
+	- Add SRCREV_FORMAT support
+	- Fix local fetcher's localpath return values
+	- Apply OVERRIDES before performing immediate expansions
+	- Allow the -b -e option combination to take regular expressions
+	- Fix handling of variables with expansion in the name using _append/_prepend
+	  e.g. RRECOMMENDS_${PN}_append_xyz = "abc"
+	- Add plain message function to bb.msg
+	- Sort the list of providers before processing so dependency problems are 
+	  reproducible rather than effectively random
+	- Fix/improve bitbake -s output
+	- Add locking for fetchers so only one tries to fetch a given file at a given time
+	- Fix int(0)/None confusion in runqueue.py which causes random gaps in dependency chains	  
+	- Expand data in addtasks
+	- Print the list of missing DEPENDS,RDEPENDS for the "No buildable providers available for required...."
+	  error message.
+	- Rework add_task to be more efficient (6% speedup, 7% number of function calls reduction)
+	- Sort digraph output to make builds more reproducible
+	- Split expandKeys into two for loops to benefit from the expand_cache (12% speedup)
+	- runqueue.py: Fix idepends handling to avoid dependency errors
+	- Clear the terminal TOSTOP flag if set (and warn the user)
+	- Fix regression from r653 and make SRCDATE/CVSDATE work for packages again
+	- Fix a bug in bb.decodeurl where http://some.where.com/somefile.tgz decoded to host="" (#1530)
+	- Warn about malformed PREFERRED_PROVIDERS (#1072)
+	- Add support for BB_NICE_LEVEL option (#1627)
+	- Psyco is used only on x86 as there is no support for other architectures.
+	- Sort initial providers list by default preference (#1145, #2024)
+	- Improve provider sorting so prefered versions have preference over latest versions (#768)
+	- Detect builds of tasks with overlapping providers and warn (will become a fatal error) (#1359)
+	- Add MULTI_PROVIDER_WHITELIST variable to allow known safe multiple providers to be listed
+	- Handle paths in svn fetcher module parameter
+	- Support the syntax "export VARIABLE"
+	- Add bzr fetcher
+	- Add support for cleaning directories before a task in the form:
+	  do_taskname[cleandirs] = "dir"
+	- bzr fetcher tweaks from Robert Schuster (#2913)
+	- Add mercurial (hg) fetcher from Robert Schuster (#2913)
+	- Don't add duplicates to BBPATH
+	- Fix preferred_version return values (providers.py)
+	- Fix 'depends' flag splitting
+	- Fix unexport handling (#3135)
+	- Add bb.copyfile function similar to bb.movefile (and improve movefile error reporting)
+	- Allow multiple options for deptask flag
+	- Use git-fetch instead of git-pull removing any need for merges when 
+	  fetching (we don't care about the index). Fixes fetch errors.
+	- Add BB_GENERATE_MIRROR_TARBALLS option, set to 0 to make git fetches 
+	  faster at the expense of not creating mirror tarballs.
+	- SRCREV handling updates, improvements and fixes from Poky
+	- Add bb.utils.lockfile() and bb.utils.unlockfile() from Poky
+	- Add support for task selfstamp and lockfiles flags
+	- Disable task number acceleration since it can allow the tasks to run 
+	  out of sequence
+	- Improve runqueue code comments
+	- Add task scheduler abstraction and some example schedulers
+	- Improve circular dependency chain debugging code and user feedback
+	- Don't give a stacktrace for invalid tasks, have a user friendly message (#3431)
+	- Add support for "-e target" (#3432)
+	- Fix shell showdata command (#3259)
+	- Fix shell data updating problems (#1880)
+	- Properly raise errors for invalid source URI protocols
+	- Change the wget fetcher failure handling to avoid lockfile problems
+	- Add support for branches in git fetcher (Otavio Salvador, Michael Lauer)
+	- Make taskdata and runqueue errors more user friendly
+	- Add norecurse and fullpath options to cvs fetcher
+	- Fix exit code for build failures in --continue mode
+	- Fix git branch tags fetching
+	- Change parseConfigurationFile so it works on real data, not a copy
+	- Handle 'base' inherit and all other INHERITs from parseConfigurationFile 
+	  instead of BBHandler
+	- Fix getVarFlags bug in data_smart
+	- Optmise cache handling by more quickly detecting an invalid cache, only 
+	  saving the cache when its changed, moving the cache validity check into
+	  the parsing loop and factoring some getVar calls outside a for loop
+	- Cooker: Remove a debug message from the parsing loop to lower overhead
+	- Convert build.py exec_task to use getVarFlags
+	- Update shell to use cooker.buildFile
+	- Add StampUpdate event
+	- Convert -b option to use taskdata/runqueue
+	- Remove digraph and switch to new stamp checking code. exec_task no longer
+	  honours dependencies
+	- Make fetcher timestamp updating non-fatal when permissions don't allow 
+	  updates
+	- Add BB_SCHEDULER variable/option ("completion" or "speed") controlling
+	  the way bitbake schedules tasks
+	- Add BB_STAMP_POLICY variable/option ("perfile" or "full") controlling
+	  how extensively stamps are looked at for validity
+	- When handling build target failures make sure idepends are checked and
+	  failed where needed. Fixes --continue mode crashes.
+	- Fix -f (force) in conjunction with -b
+	- Fix problems with recrdeptask handling where some idepends weren't handled
+	  correctly.
+	- Handle exit codes correctly (from pH5)
+	- Work around refs/HEAD issues with git over http (#3410)
+	- Add proxy support to the CVS fetcher (from Cyril Chemparathy)
+	- Improve runfetchcmd so errors are seen and various GIT variables are exported
+	- Add ability to fetchers to check URL validity without downloading
+	- Improve runtime PREFERRED_PROVIDERS warning message
+	- Add BB_STAMP_WHITELIST option which contains a list of stamps to ignore when
+	  checking stamp dependencies and using a BB_STAMP_POLICY of "whitelist"
+	- No longer weight providers on the basis of a package being "already staged". This
+	  leads to builds being non-deterministic.
+	- Flush stdout/stderr before forking to fix duplicate console output
+	- Make sure recrdeps tasks include all inter-task dependencies of a given fn
+	- Add bb.runqueue.check_stamp_fn() for use by packaged-staging
+	- Add PERSISTENT_DIR to store the PersistData in a persistent
+	  directory != the cache dir.
+	- Add md5 and sha256 checksum generation functions to utils.py
+	- Correctly handle '-' characters in class names (#2958)
+	- Make sure expandKeys has been called on the data dictionary before running tasks
+	- Correctly add a task override in the form task-TASKNAME.
+	- Revert the '-' character fix in class names since it breaks things
+	- When a regexp fails to compile for PACKAGES_DYNAMIC, print a more useful error (#4444)
+	- Allow to checkout CVS by Date and Time. Just add HHmm to the SRCDATE.
+	- Move prunedir function to utils.py and add explode_dep_versions function
+	- Raise an exception if SRCREV == 'INVALID'
+	- Fix hg fetcher username/password handling and fix crash
+	- Fix PACKAGES_DYNAMIC handling of packages with '++' in the name
+	- Rename __depends to __base_depends after configuration parsing so we don't
+	  recheck the validity of the config files time after time
+	- Add better environmental variable handling. By default it will now only pass certain 
+	  whitelisted variables into the data store. If BB_PRESERVE_ENV is set bitbake will use
+	  all variable from the environment. If BB_ENV_WHITELIST is set, that whitelist will be
+	  used instead of the internal bitbake one. Alternatively, BB_ENV_EXTRAWHITE can be used
+	  to extend the internal whitelist.
+	- Perforce fetcher fix to use commandline options instead of being overriden by the environment
+	- bb.utils.prunedir can cope with symlinks to directoriees without exceptions
+	- use @rev when doing a svn checkout
+	- Add osc fetcher (from Joshua Lock in Poky)
+	- When SRCREV autorevisioning for a recipe is in use, don't cache the recipe
+	- Add tryaltconfigs option to control whether bitbake trys using alternative providers
+	  to fulfil failed dependencies. It defaults to off, changing the default since this
+	  behaviour confuses many users and isn't often useful.
+	- Improve lock file function error handling
+	- Add username handling to the git fetcher (Robert Bragg)
+	- Add support for HTTP_PROXY and HTTP_PROXY_IGNORE variables to the wget fetcher
+	- Export more variables to the fetcher commands to allow ssh checkouts and checkouts through 
+	  proxies to work better. (from Poky)
+	- Also allow user and pswd options in SRC_URIs globally (from Poky)
+	- Improve proxy handling when using mirrors (from Poky)
+	- Add bb.utils.prune_suffix function
+	- Fix hg checkouts of specific revisions (from Poky)
+	- Fix wget fetching of urls with parameters specified (from Poky)
+	- Add username handling to git fetcher (from Poky)
+	- Set HOME environmental variable when running fetcher commands (from Poky)
+	- Make sure allowed variables inherited from the environment are exported again (from Poky)
+	- When running a stage task in bbshell, run populate_staging, not the stage task (from Poky)
+	- Fix + character escaping from PACKAGES_DYNAMIC (thanks Otavio Salvador)
+	- Addition of BBCLASSEXTEND support for allowing one recipe to provide multiple targets (from Poky)

 Changes in Bitbake 1.8.0:
 	- Release 1.7.x as a stable series
--- a/bitbake/MANIFEST
+++ b/bitbake/MANIFEST
@@ -1,49 +0,0 @@
-AUTHORS
-COPYING
-ChangeLog
-MANIFEST
-setup.py
-bin/bitdoc
-bin/bbimage
-bin/bitbake
-lib/bb/__init__.py
-lib/bb/build.py
-lib/bb/cache.py
-lib/bb/cooker.py
-lib/bb/COW.py
-lib/bb/data.py
-lib/bb/data_smart.py
-lib/bb/event.py
-lib/bb/fetch/__init__.py
-lib/bb/fetch/cvs.py
-lib/bb/fetch/git.py
-lib/bb/fetch/local.py
-lib/bb/fetch/perforce.py
-lib/bb/fetch/ssh.py
-lib/bb/fetch/svk.py
-lib/bb/fetch/svn.py
-lib/bb/fetch/wget.py
-lib/bb/manifest.py
-lib/bb/methodpool.py
-lib/bb/msg.py
-lib/bb/parse/__init__.py
-lib/bb/parse/parse_py/__init__.py
-lib/bb/parse/parse_py/BBHandler.py
-lib/bb/parse/parse_py/ConfHandler.py
-lib/bb/providers.py
-lib/bb/runqueue.py
-lib/bb/shell.py
-lib/bb/taskdata.py
-lib/bb/utils.py
-setup.py
-doc/COPYING.GPL
-doc/COPYING.MIT
-doc/bitbake.1
-doc/manual/html.css
-doc/manual/Makefile
-doc/manual/usermanual.xml
-contrib/bbdev.sh
-contrib/vim/syntax/bitbake.vim
-contrib/vim/ftdetect/bitbake.vim
-conf/bitbake.conf
-classes/base.bbclass
--- a/bitbake/bin/bbimage
+++ b/bitbake/bin/bbimage
@@ -1,155 +0,0 @@
-#!/usr/bin/env python
-# ex:ts=4:sw=4:sts=4:et
-# -*- tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*-
-#
-# Copyright (C) 2003  Chris Larson
-#
-#    This program is free software; you can redistribute it and/or modify
-#    it under the terms of the GNU General Public License version 2 as
-#    published by the Free Software Foundation.
-#
-#    This program is distributed in the hope that it will be useful,
-#    but WITHOUT ANY WARRANTY; without even the implied warranty of
-#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-#    GNU General Public License for more details.
-#
-#    You should have received a copy of the GNU General Public License along
-#    with this program; if not, write to the Free Software Foundation, Inc.,
-#    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-import sys, os
-sys.path.insert(0,os.path.join(os.path.dirname(os.path.dirname(sys.argv[0])), 'lib'))
-import bb
-from bb import *
-
-__version__ = 1.1
-type = "jffs2"
-cfg_bb = data.init()
-cfg_oespawn = data.init()
-
-bb.msg.set_debug_level(0)
-
-def usage():
-    print "Usage: bbimage [options ...]"
-    print "Creates an image for a target device from a root filesystem,"
-    print "obeying configuration parameters from the BitBake"
-    print "configuration files, thereby easing handling of deviceisms."
-    print ""
-    print "  %s\t\t%s" % ("-r [arg], --root [arg]", "root directory (default=${IMAGE_ROOTFS})")
-    print "  %s\t\t%s" % ("-t [arg], --type [arg]", "image type (jffs2[default], cramfs)")
-    print "  %s\t\t%s" % ("-n [arg], --name [arg]", "image name (override IMAGE_NAME variable)")
-    print "  %s\t\t%s" % ("-v, --version", "output version information and exit")
-    sys.exit(0)
-
-def version():
-    print "BitBake Build Tool Core version %s" % bb.__version__
-    print "BBImage version %s" % __version__
-
-def emit_bb(d, base_d = {}):
-    for v in d.keys():
-        if d[v] != base_d[v]:
-            data.emit_var(v, d)
-
-def getopthash(l):
-    h = {}
-    for (opt, val) in l:
-        h[opt] = val
-    return h
-
-import getopt
-try:
-    (opts, args) = getopt.getopt(sys.argv[1:], 'vr:t:e:n:', [ 'version', 'root=', 'type=', 'bbfile=', 'name=' ])
-except getopt.GetoptError:
-    usage()
-
-# handle opts
-opthash = getopthash(opts)
-
-if '--version' in opthash or '-v' in opthash:
-    version()
-    sys.exit(0)
-
-try:
-    cfg_bb = parse.handle(os.path.join('conf', 'bitbake.conf'), cfg_bb)
-except IOError:
-    fatal("Unable to open bitbake.conf")
-
-# sanity check
-if cfg_bb is None:
-    fatal("Unable to open/parse %s" % os.path.join('conf', 'bitbake.conf'))
-    usage(1)
-
-rootfs = None
-extra_files = []
-
-if '--root' in opthash:
-    rootfs = opthash['--root']
-if '-r' in opthash:
-    rootfs = opthash['-r']
-
-if '--type' in opthash:
-    type = opthash['--type']
-if '-t' in opthash:
-    type = opthash['-t']
-
-if '--bbfile' in opthash:
-    extra_files.append(opthash['--bbfile'])
-if '-e' in opthash:
-    extra_files.append(opthash['-e'])
-
-for f in extra_files:
-    try:
-        cfg_bb = parse.handle(f, cfg_bb)
-    except IOError:
-        print "unable to open %s" % f
-
-if not rootfs:
-    rootfs = data.getVar('IMAGE_ROOTFS', cfg_bb, 1)
-
-if not rootfs:
-    bb.fatal("IMAGE_ROOTFS not defined")
-
-data.setVar('IMAGE_ROOTFS', rootfs, cfg_bb)
-
-from copy import copy, deepcopy
-localdata = data.createCopy(cfg_bb)
-
-overrides = data.getVar('OVERRIDES', localdata)
-if not overrides:
-    bb.fatal("OVERRIDES not defined.")
-data.setVar('OVERRIDES', '%s:%s' % (overrides, type), localdata)
-data.update_data(localdata)
-data.setVar('OVERRIDES', overrides, localdata)
-
-if '-n' in opthash:
-    data.setVar('IMAGE_NAME', opthash['-n'], localdata)
-if '--name' in opthash:
-    data.setVar('IMAGE_NAME', opthash['--name'], localdata)
-
-topdir = data.getVar('TOPDIR', localdata, 1) or os.getcwd()
-
-cmd = data.getVar('IMAGE_CMD', localdata, 1)
-if not cmd:
-    bb.fatal("IMAGE_CMD not defined")
-
-outdir = data.getVar('DEPLOY_DIR_IMAGE', localdata, 1)
-if not outdir:
-    bb.fatal('DEPLOY_DIR_IMAGE not defined')
-mkdirhier(outdir)
-
-#depends = data.getVar('IMAGE_DEPENDS', localdata, 1) or ""
-#if depends:
-#       bb.note("Spawning bbmake to satisfy dependencies: %s" % depends)
-#       ret = os.system('bbmake %s' % depends)
-#       if ret != 0:
-#           bb.error("executing bbmake to satisfy dependencies")
-
-bb.note("Executing %s" % cmd)
-data.setVar('image_cmd', cmd, localdata)
-data.setVarFlag('image_cmd', 'func', 1, localdata)
-try:
-    bb.build.exec_func('image_cmd', localdata)
-except bb.build.FuncFailed:
-    sys.exit(1)
-#ret = os.system(cmd)
-#sys.exit(ret)
--- a/bitbake/bin/bitbake
+++ b/bitbake/bin/bitbake
@@ -22,96 +22,196 @@
 # with this program; if not, write to the Free Software Foundation, Inc.,
 # 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.

-import sys, os, getopt, re, time, optparse
-sys.path.insert(0,os.path.join(os.path.dirname(os.path.dirname(sys.argv[0])), 'lib'))
-import bb
-from bb import cooker
+import os
+import sys
+sys.path.insert(0, os.path.join(os.path.dirname(os.path.dirname(sys.argv[0])),
+                                'lib'))
+
+import optparse
+import warnings
+from traceback import format_exception
+import bb
+import bb.msg
+from bb import cooker
+from bb import ui
+from bb import server
+from bb.server import none
+#from bb.server import xmlrpc
+
+__version__ = "1.11.0"
+

-__version__ = "1.8.5"

 #============================================================================#
 # BBOptions
 #============================================================================#
-class BBConfiguration( object ):
+class BBConfiguration(object):
    """
    Manages build options and configurations for one run
    """
-    def __init__( self, options ):
-        for key, val in options.__dict__.items():
-            setattr( self, key, val )

+    def __init__(self, options):
+        for key, val in options.__dict__.items():
+            setattr(self, key, val)
+        self.pkgs_to_build = []
+
+
+def print_exception(exc, value, tb):
+    """Send exception information through bb.msg"""
+    bb.fatal("".join(format_exception(exc, value, tb, limit=8)))
+
+sys.excepthook = print_exception
+
+
+_warnings_showwarning = warnings.showwarning
+def _showwarning(message, category, filename, lineno, file=None, line=None):
+    """Display python warning messages using bb.msg"""
+    if file is not None:
+        if _warnings_showwarning is not None:
+            _warnings_showwarning(message, category, filename, lineno, file, line)
+    else:
+        s = warnings.formatwarning(message, category, filename, lineno)
+        s = s.split("\n")[0]
+        bb.msg.warn(None, s)
+
+warnings.showwarning = _showwarning
+warnings.simplefilter("ignore", DeprecationWarning)

 #============================================================================#
 # main
 #============================================================================#

 def main():
-    parser = optparse.OptionParser( version = "BitBake Build Tool Core version %s, %%prog version %s" % ( bb.__version__, __version__ ),
-    usage = """%prog [options] [package ...]
+    return_value = 1
+
+    parser = optparse.OptionParser(
+        version = "BitBake Build Tool Core version %s, %%prog version %s" % (bb.__version__, __version__),
+        usage = """%prog [options] [package ...]

 Executes the specified task (default is 'build') for a given set of BitBake files.
-It expects that BBFILES is defined, which is a space seperated list of files to
+It expects that BBFILES is defined, which is a space separated list of files to
 be executed.  BBFILES does support wildcards.
-Default BBFILES are the .bb files in the current directory.""" )
+Default BBFILES are the .bb files in the current directory.""")

-    parser.add_option( "-b", "--buildfile", help = "execute the task against this .bb file, rather than a package from BBFILES.",
-               action = "store", dest = "buildfile", default = None )
+    parser.add_option("-b", "--buildfile", help = "execute the task against this .bb file, rather than a package from BBFILES.",
+               action = "store", dest = "buildfile", default = None)

-    parser.add_option( "-k", "--continue", help = "continue as much as possible after an error. While the target that failed, and those that depend on it, cannot be remade, the other dependencies of these targets can be processed all the same.",
-               action = "store_false", dest = "abort", default = True )
+    parser.add_option("-k", "--continue", help = "continue as much as possible after an error. While the target that failed, and those that depend on it, cannot be remade, the other dependencies of these targets can be processed all the same.",
+               action = "store_false", dest = "abort", default = True)

-    parser.add_option( "-f", "--force", help = "force run of specified cmd, regardless of stamp status",
-               action = "store_true", dest = "force", default = False )
+    parser.add_option("-a", "--tryaltconfigs", help = "continue with builds by trying to use alternative providers where possible.",
+               action = "store_true", dest = "tryaltconfigs", default = False)

-    parser.add_option( "-i", "--interactive", help = "drop into the interactive mode also called the BitBake shell.",
-               action = "store_true", dest = "interactive", default = False )
+    parser.add_option("-f", "--force", help = "force run of specified cmd, regardless of stamp status",
+               action = "store_true", dest = "force", default = False)

-    parser.add_option( "-c", "--cmd", help = "Specify task to execute. Note that this only executes the specified task for the providee and the packages it depends on, i.e. 'compile' does not implicitly call stage for the dependencies (IOW: use only if you know what you are doing). Depending on the base.bbclass a listtasks tasks is defined and will show available tasks",
-               action = "store", dest = "cmd" )
+    parser.add_option("-c", "--cmd", help = "Specify task to execute. Note that this only executes the specified task for the providee and the packages it depends on, i.e. 'compile' does not implicitly call stage for the dependencies (IOW: use only if you know what you are doing). Depending on the base.bbclass a listtasks tasks is defined and will show available tasks",
+               action = "store", dest = "cmd")

-    parser.add_option( "-r", "--read", help = "read the specified file before bitbake.conf",
-               action = "append", dest = "file", default = [] )
+    parser.add_option("-r", "--read", help = "read the specified file before bitbake.conf",
+               action = "append", dest = "file", default = [])

-    parser.add_option( "-v", "--verbose", help = "output more chit-chat to the terminal",
-               action = "store_true", dest = "verbose", default = False )
+    parser.add_option("-v", "--verbose", help = "output more chit-chat to the terminal",
+               action = "store_true", dest = "verbose", default = False)

-    parser.add_option( "-D", "--debug", help = "Increase the debug level. You can specify this more than once.",
+    parser.add_option("-D", "--debug", help = "Increase the debug level. You can specify this more than once.",
               action = "count", dest="debug", default = 0)

-    parser.add_option( "-n", "--dry-run", help = "don't execute, just go through the motions",
-               action = "store_true", dest = "dry_run", default = False )
+    parser.add_option("-n", "--dry-run", help = "don't execute, just go through the motions",
+               action = "store_true", dest = "dry_run", default = False)

-    parser.add_option( "-p", "--parse-only", help = "quit after parsing the BB files (developers only)",
-               action = "store_true", dest = "parse_only", default = False )
+    parser.add_option("-S", "--dump-signatures", help = "don't execute, just dump out the signature construction information",
+               action = "store_true", dest = "dump_signatures", default = False)

-    parser.add_option( "-d", "--disable-psyco", help = "disable using the psyco just-in-time compiler (not recommended)",
-               action = "store_true", dest = "disable_psyco", default = False )
+    parser.add_option("-p", "--parse-only", help = "quit after parsing the BB files (developers only)",
+               action = "store_true", dest = "parse_only", default = False)

-    parser.add_option( "-s", "--show-versions", help = "show current and preferred versions of all packages",
-               action = "store_true", dest = "show_versions", default = False )
+    parser.add_option("-d", "--disable-psyco", help = "disable using the psyco just-in-time compiler (not recommended)",
+               action = "store_true", dest = "disable_psyco", default = False)

-    parser.add_option( "-e", "--environment", help = "show the global or per-package environment (this is what used to be bbread)",
-               action = "store_true", dest = "show_environment", default = False )
+    parser.add_option("-s", "--show-versions", help = "show current and preferred versions of all packages",
+               action = "store_true", dest = "show_versions", default = False)

-    parser.add_option( "-g", "--graphviz", help = "emit the dependency trees of the specified packages in the dot syntax",
-                action = "store_true", dest = "dot_graph", default = False )
+    parser.add_option("-e", "--environment", help = "show the global or per-package environment (this is what used to be bbread)",
+               action = "store_true", dest = "show_environment", default = False)

-    parser.add_option( "-I", "--ignore-deps", help = """Stop processing at the given list of dependencies when generating dependency graphs. This can help to make the graph more appealing""",
-                action = "append", dest = "ignored_dot_deps", default = [] )
+    parser.add_option("-g", "--graphviz", help = "emit the dependency trees of the specified packages in the dot syntax",
+                action = "store_true", dest = "dot_graph", default = False)

-    parser.add_option( "-l", "--log-domains", help = """Show debug logging for the specified logging domains""",
-                action = "append", dest = "debug_domains", default = [] )
+    parser.add_option("-I", "--ignore-deps", help = """Assume these dependencies don't exist and are already provided (equivalent to ASSUME_PROVIDED). Useful to make dependency graphs more appealing""",
+                action = "append", dest = "extra_assume_provided", default = [])

+    parser.add_option("-l", "--log-domains", help = """Show debug logging for the specified logging domains""",
+                action = "append", dest = "debug_domains", default = [])
+
+    parser.add_option("-P", "--profile", help = "profile the command and print a report",
+               action = "store_true", dest = "profile", default = False)
+
+    parser.add_option("-u", "--ui", help = "userinterface to use",
+               action = "store", dest = "ui")
+
+    parser.add_option("", "--revisions-changed", help = "Set the exit code depending on whether upstream floating revisions have changed or not",
+               action = "store_true", dest = "revisions_changed", default = False)

    options, args = parser.parse_args(sys.argv)

    configuration = BBConfiguration(options)
-    configuration.pkgs_to_build = []
    configuration.pkgs_to_build.extend(args[1:])
+    configuration.initial_path = os.environ['PATH']

-    cooker = bb.cooker.BBCooker(configuration)
-    cooker.cook()
+    #server = bb.server.xmlrpc
+    server = bb.server.none

+    # Save a logfile for cooker into the current working directory. When the
+    # server is daemonized this logfile will be truncated.
+    cooker_logfile = os.path.join(os.getcwd(), "cooker.log")
+
+    bb.utils.init_logger(bb.msg, configuration.verbose, configuration.debug,
+                         configuration.debug_domains)
+
+    # Clear away any spurious environment variables. But don't wipe the
+    # environment totally. This is necessary to ensure the correct operation
+    # of the UIs (e.g. for DISPLAY, etc.)
+    bb.utils.clean_environment()
+
+    cooker = bb.cooker.BBCooker(configuration, server)
+
+    cooker.parseCommandLine()
+
+    serverinfo = server.BitbakeServerInfo(cooker.server)
+
+    server.BitBakeServerFork(serverinfo, cooker.serve, cooker_logfile)
+    del cooker
+
+    # Setup a connection to the server (cooker)
+    serverConnection = server.BitBakeServerConnection(serverinfo)
+
+    # Launch the UI
+    if configuration.ui:
+        ui = configuration.ui
+    else:
+        ui = "knotty"
+
+    try:
+        # Dynamically load the UI based on the ui name. Although we
+        # suggest a fixed set this allows you to have flexibility in which
+        # ones are available.
+        uimodule = __import__("bb.ui", fromlist = [ui])
+        ui_init = getattr(uimodule, ui).init
+    except AttributeError:
+        print("FATAL: Invalid user interface '%s' specified. " % ui)
+        print("Valid interfaces are 'ncurses', 'depexp' or the default, 'knotty'.")
+    else:
+        try:
+            return_value = ui_init(serverConnection.connection, serverConnection.events)
+        except Exception as e:
+            print("FATAL: Unable to start to '%s' UI: %s" % (ui, e))
+            raise
+    finally:
+        serverConnection.terminate()
+
+    return return_value

 if __name__ == "__main__":
-    main()
+    ret = main()
+    sys.exit(ret)
--- a/bitbake/bin/bitbake-diffsigs
+++ b/bitbake/bin/bitbake-diffsigs
@@ -0,0 +1,12 @@
+#!/usr/bin/env python
+import os
+import sys
+import warnings
+sys.path.insert(0, os.path.join(os.path.dirname(os.path.dirname(sys.argv[0])), 'lib'))
+
+import bb.siggen
+
+if len(sys.argv) > 2:
+    bb.siggen.compare_sigfiles(sys.argv[1], sys.argv[2])
+else:
+    bb.siggen.dump_sigfile(sys.argv[1])
--- a/bitbake/bin/bitbake-runtask
+++ b/bitbake/bin/bitbake-runtask
@@ -0,0 +1,117 @@
+#!/usr/bin/env python
+
+import os
+import sys
+import warnings
+sys.path.insert(0, os.path.join(os.path.dirname(os.path.dirname(sys.argv[0])), 'lib'))
+
+try:
+    import cPickle as pickle
+except ImportError:
+    import pickle
+    bb.msg.note(1, bb.msg.domain.Cache, "Importing cPickle failed. Falling back to a very slow implementation.")
+
+class BBConfiguration(object):
+    """
+    Manages build options and configurations for one run
+    """
+
+    def __init__(self, debug, debug_domains):
+        setattr(self, "data", {})
+        setattr(self, "file", [])
+        setattr(self, "cmd", None)
+        setattr(self, "dump_signatures", True)
+        setattr(self, "debug", debug)
+        setattr(self, "debug_domains", debug_domains)
+
+_warnings_showwarning = warnings.showwarning
+def _showwarning(message, category, filename, lineno, file=None, line=None):
+    """Display python warning messages using bb.msg"""
+    if file is not None:
+        if _warnings_showwarning is not None:
+            _warnings_showwarning(message, category, filename, lineno, file, line)
+    else:
+        s = warnings.formatwarning(message, category, filename, lineno)
+        s = s.split("\n")[0]
+        bb.msg.warn(None, s)
+
+warnings.showwarning = _showwarning
+warnings.simplefilter("ignore", DeprecationWarning)
+
+import bb.event
+
+# Need to map our I/O correctly. stdout is a pipe to the server expecting 
+# events. We save this and then map stdout to stderr.
+
+eventfd = os.dup(sys.stdout.fileno())
+bb.event.worker_pipe = os.fdopen(eventfd, 'w', 0)
+
+# map stdout to stderr
+os.dup2(sys.stderr.fileno(), sys.stdout.fileno())
+
+# Replace those fds with our own
+#logout = data.expand("${TMPDIR}/log/stdout.%s" % os.getpid(), self.cfgData, True)
+#mkdirhier(os.path.dirname(logout))
+#newso = open("/tmp/stdout.%s" % os.getpid(), 'w')
+#os.dup2(newso.fileno(), sys.stdout.fileno())
+#os.dup2(newso.fileno(), sys.stderr.fileno())
+
+# Don't read from stdin from the parent
+si = file("/dev/null", 'r')
+os.dup2(si.fileno( ), sys.stdin.fileno( ))
+
+# We don't want to see signals to our parent, e.g. Ctrl+C
+os.setpgrp()
+
+# Save out the PID so that the event can include it the
+# events
+bb.event.worker_pid = os.getpid()
+bb.event.useStdout = False
+
+hashfile = sys.argv[1]
+buildfile = sys.argv[2]
+taskname = sys.argv[3]
+
+import bb.cooker
+
+p = pickle.Unpickler(file(hashfile, "rb"))
+hashdata = p.load()
+
+debug = hashdata["msg-debug"]
+debug_domains = hashdata["msg-debug-domains"]
+verbose = hashdata["verbose"]
+
+bb.utils.init_logger(bb.msg, verbose, debug, debug_domains)
+
+cooker = bb.cooker.BBCooker(BBConfiguration(debug, debug_domains), None)
+cooker.parseConfiguration()
+
+cooker.bb_cache = bb.cache.init(cooker)
+cooker.status = bb.cache.CacheData()
+
+(fn, cls) = cooker.bb_cache.virtualfn2realfn(buildfile)
+buildfile = cooker.matchFile(fn)
+fn = cooker.bb_cache.realfn2virtual(buildfile, cls)
+
+cooker.buildSetVars()
+
+# Load data into the cache for fn and parse the loaded cache data
+the_data = cooker.bb_cache.loadDataFull(fn, cooker.get_file_appends(fn), cooker.configuration.data)
+cooker.bb_cache.setData(fn, buildfile, the_data)
+cooker.bb_cache.handle_data(fn, cooker.status)
+
+if taskname.endswith("_setscene"):
+    the_data.setVarFlag(taskname, "quieterrors", "1")
+
+bb.parse.siggen.set_taskdata(hashdata["hashes"], hashdata["deps"])
+
+for h in hashdata["hashes"]:
+    bb.data.setVar("BBHASH_%s" % h, hashdata["hashes"][h], the_data)
+for h in hashdata["deps"]:
+    bb.data.setVar("BBHASHDEPS_%s" % h, hashdata["deps"][h], the_data)
+
+ret = 0
+if sys.argv[4] != "True":
+    ret = bb.build.exec_task(fn, taskname, the_data)
+sys.exit(ret)
+
--- a/bitbake/bin/bitdoc
+++ b/bitbake/bin/bitdoc
@@ -48,7 +48,7 @@ class HTMLFormatter:
        From pydoc... almost identical at least
        """
        while pairs:
-            (a,b) = pairs[0]
+            (a, b) = pairs[0]
            text = join(split(text, a), b)
            pairs = pairs[1:]
        return text
@@ -87,7 +87,7 @@ class HTMLFormatter:

        return txt + ",".join(txts)

-    def groups(self,item):
+    def groups(self, item):
        """
        Create HTML to link to related groups
        """
@@ -99,12 +99,12 @@ class HTMLFormatter:
        txt = "<p><b>See also:</b><br>"
        txts = []
        for group in item.groups():
-            txts.append( """<a href="group%s.html">%s</a> """ % (group,group) )
+            txts.append( """<a href="group%s.html">%s</a> """ % (group, group) )

        return txt + ",".join(txts)


-    def createKeySite(self,item):
+    def createKeySite(self, item):
        """
        Create a site for a key. It contains the header/navigator, a heading,
        the description, links to related keys and to the groups.
@@ -149,8 +149,7 @@ class HTMLFormatter:
        """

        groups = ""
-        sorted_groups = doc.groups()
-        sorted_groups.sort()
+        sorted_groups = sorted(doc.groups())
        for group in sorted_groups:
            groups += """<a href="group%s.html">%s</a><br>""" % (group, group)

@@ -185,8 +184,7 @@ class HTMLFormatter:
        Create Overview of all avilable keys
        """
        keys = ""
-        sorted_keys = doc.doc_keys()
-        sorted_keys.sort()
+        sorted_keys = sorted(doc.doc_keys())
        for key in sorted_keys:
            keys += """<a href="key%s.html">%s</a><br>""" % (key, key)

@@ -214,7 +212,7 @@ class HTMLFormatter:
            description  += "<h2 Description of Grozp %s</h2>" % gr
            description  += _description

-        items.sort(lambda x,y:cmp(x.name(),y.name()))
+        items.sort(lambda x, y:cmp(x.name(), y.name()))
        for group in items:
            groups += """<a href="key%s.html">%s</a><br>""" % (group.name(), group.name())

@@ -343,7 +341,7 @@ class DocumentationItem:
    def addGroup(self, group):
        self._groups.append(group)

-    def addRelation(self,relation):
+    def addRelation(self, relation):
        self._related.append(relation)

    def sort(self):
@@ -396,7 +394,7 @@ class Documentation:
        """
        return self.__groups.keys()

-    def group_content(self,group_name):
+    def group_content(self, group_name):
        """
        Return a list of keys/names that are in a specefic
        group or the empty list
@@ -412,7 +410,7 @@ def parse_cmdline(args):
    Parse the CMD line and return the result as a n-tuple
    """

-    parser = optparse.OptionParser( version = "Bitbake Documentation Tool Core version %s, %%prog version %s" % (bb.__version__,__version__))
+    parser = optparse.OptionParser( version = "Bitbake Documentation Tool Core version %s, %%prog version %s" % (bb.__version__, __version__))
    usage  = """%prog [options]

 Create a set of html pages (documentation) for a bitbake.conf....
@@ -428,7 +426,7 @@ Create a set of html pages (documentation) for a bitbake.conf....
    parser.add_option( "-D",  "--debug", help = "Increase the debug level",
                       action = "count", dest = "debug", default = 0 )

-    parser.add_option( "-v","--verbose", help = "output more chit-char to the terminal",
+    parser.add_option( "-v", "--verbose", help = "output more chit-char to the terminal",
                       action = "store_true", dest = "verbose", default = False )

    options, args = parser.parse_args( sys.argv )
@@ -443,7 +441,7 @@ def main():
    The main Method
    """

-    (config_file,output_dir) = parse_cmdline( sys.argv )
+    (config_file, output_dir) = parse_cmdline( sys.argv )

    # right to let us load the file now
    try:
@@ -453,6 +451,8 @@ def main():
    except bb.parse.ParseError:
        bb.fatal( "Unable to parse %s" % config_file )

+    if isinstance(documentation, dict):
+        documentation = documentation[""]

    # Assuming we've the file loaded now, we will initialize the 'tree'
    doc = Documentation()
--- a/bitbake/contrib/vim/syntax/bitbake.vim
+++ b/bitbake/contrib/vim/syntax/bitbake.vim
@@ -16,12 +16,17 @@ endif

 syn case match

-
 " Catch incorrect syntax (only matches if nothing else does)
 "
 syn match bbUnmatched		"."


+syn include @python syntax/python.vim
+if exists("b:current_syntax")
+  unlet b:current_syntax
+endif
+
+
 " Other

 syn match bbComment		"^#.*$" display contains=bbTodo
@@ -34,21 +39,25 @@ syn match bbArrayBrackets	"[\[\]]" contained
 " BitBake strings

 syn match bbContinue		"\\$"
-syn region bbString		matchgroup=bbQuote start=/"/ skip=/\\$/ excludenl end=/"/ contained keepend contains=bbTodo,bbContinue,bbVarDeref
-syn region bbString		matchgroup=bbQuote start=/'/ skip=/\\$/ excludenl end=/'/ contained keepend contains=bbTodo,bbContinue,bbVarDeref
-
+syn region bbString		matchgroup=bbQuote start=/"/ skip=/\\$/ excludenl end=/"/ contained keepend contains=bbTodo,bbContinue,bbVarInlinePy,bbVarDeref
+syn region bbString		matchgroup=bbQuote start=/'/ skip=/\\$/ excludenl end=/'/ contained keepend contains=bbTodo,bbContinue,bbVarInlinePy,bbVarDeref

 " BitBake variable metadata

-syn keyword bbExportFlag	export contained nextgroup=bbIdentifier skipwhite
-syn match bbVarDeref	"${[a-zA-Z0-9\-_\.]\+}" contained
-syn match bbVarDef		"^\(export\s*\)\?\([a-zA-Z0-9\-_\.]\+\(_[${}a-zA-Z0-9\-_\.]\+\)\?\)\s*\(:=\|+=\|=+\|\.=\|=\.\|?=\|=\)\@=" contains=bbExportFlag,bbIdentifier,bbVarDeref nextgroup=bbVarEq
+syn match bbVarBraces "[\${}]"
+syn region bbVarDeref matchgroup=bbVarBraces start="${" end="}" contained
+" syn region bbVarDeref start="${" end="}" contained
+" syn region bbVarInlinePy start="${@" end="}" contained contains=@python
+syn region bbVarInlinePy matchgroup=bbVarBraces start="${@" end="}" contained contains=@python

-syn match bbIdentifier		"[a-zA-Z0-9\-_\.]\+" display contained
+syn keyword bbExportFlag	export contained nextgroup=bbIdentifier skipwhite
+" syn match bbVarDeref	"${[a-zA-Z0-9\-_\.]\+}" contained
+syn match bbVarDef		"^\(export\s*\)\?\([a-zA-Z0-9\-_\.]\+\(_[${}a-zA/-Z0-9\-_\.]\+\)\?\)\s*\(:=\|+=\|=+\|\.=\|=\.\|?=\|=\)\@=" contains=bbExportFlag,bbIdentifier,bbVarDeref nextgroup=bbVarEq
+
+syn match bbIdentifier		"[a-zA-Z0-9\-_\./]\+" display contained
 "syn keyword bbVarEq	= display contained nextgroup=bbVarValue
 syn match bbVarEq		"\(:=\|+=\|=+\|\.=\|=\.\|?=\|=\)" contained nextgroup=bbVarValue
-syn match bbVarValue		".*$" contained contains=bbString,bbVarDeref
-
+syn match bbVarValue		".*$" contained contains=bbString

 " BitBake variable metadata flags
 syn match bbVarFlagDef		"^\([a-zA-Z0-9\-_\.]\+\)\(\[[a-zA-Z0-9\-_\.]\+\]\)\@=" contains=bbIdentifier nextgroup=bbVarFlagFlag
@@ -61,10 +70,6 @@ syn match bbFunction	"\h\w*" display contained


 " BitBake python metadata
-syn include @python syntax/python.vim
-if exists("b:current_syntax")
-  unlet b:current_syntax
-endif

 syn keyword bbPythonFlag	python contained nextgroup=bbFunction
 syn match bbPythonFuncDef	"^\(python\s\+\)\(\w\+\)\?\(\s*()\s*\)\({\)\@=" contains=bbPythonFlag,bbFunction,bbDelimiter nextgroup=bbPythonFuncRegion skipwhite
@@ -98,7 +103,6 @@ syn match bbStatementRest		".*$" contained contains=bbString,bbVarDeref
 "
 hi def link bbArrayBrackets	Statement
 hi def link bbUnmatched		Error
-hi def link bbVarDeref		String
 hi def link bbContinue		Special
 hi def link bbDef		Statement
 hi def link bbPythonFlag	Type
@@ -116,5 +120,8 @@ hi def link bbIdentifier	Identifier
 hi def link bbVarEq		Operator
 hi def link bbQuote		String
 hi def link bbVarValue		String
+" hi def link bbVarInlinePy	PreProc
+hi def link bbVarDeref		PreProc
+hi def link bbVarBraces		PreProc

 let b:current_syntax = "bb"
--- a/bitbake/doc/bitbake.1
+++ b/bitbake/doc/bitbake.1
@@ -32,7 +32,7 @@ command.
 \fBbitbake\fP is a program that executes the specified task (default is 'build')
 for a given set of BitBake files.
 .br
-It expects that BBFILES is defined, which is a space seperated list of files to
+It expects that BBFILES is defined, which is a space separated list of files to
 be executed. BBFILES does support wildcards.
 .br
 Default BBFILES are the .bb files in the current directory.
@@ -54,6 +54,9 @@ continue as much as possible after an error. While the target that failed, and
 those that depend on it, cannot be remade, the other dependencies of these
 targets can be processed all the same.
 .TP
+.B \-a, \-\-tryaltconfigs
+continue with builds by trying to use alternative providers where possible.
+.TP
 .B \-f, \-\-force
 force run of specified cmd, regardless of stamp status
 .TP
@@ -64,7 +67,7 @@ drop into the interactive mode also called the BitBake shell.
 Specify task to execute. Note that this only executes the specified task for
 the providee and the packages it depends on, i.e. 'compile' does not implicitly
 call stage for the dependencies (IOW: use only if you know what you are doing).
-Depending on the base.bbclass a listtaks tasks is defined and will show
+Depending on the base.bbclass a listtasks task is defined and will show
 available tasks.
 .TP
 .B \-rFILE, \-\-read=FILE 
@@ -97,12 +100,13 @@ emit the dependency trees of the specified packages in the dot syntax
 .B \-IIGNORED\_DOT\_DEPS, \-\-ignore-deps=IGNORED_DOT_DEPS
 Stop processing at the given list of dependencies when generating dependency
 graphs. This can help to make the graph more appealing
-.\"
-.\" Next option is only in BitBake 1.7.x (trunk)
-.\"
-.\".TP
-.\".B \-lDEBUG_DOMAINS, \-\-log-domains=DEBUG_DOMAINS
-.\"Show debug logging for the specified logging domains
+.TP
+.B \-lDEBUG_DOMAINS, \-\-log-domains=DEBUG_DOMAINS
+Show debug logging for the specified logging domains
+.TP
+.B \-P, \-\-profile
+profile the command and print a report
+.TP

 .SH AUTHORS
 BitBake was written by 
--- a/bitbake/doc/manual/usermanual.xml
+++ b/bitbake/doc/manual/usermanual.xml
@@ -88,6 +88,17 @@ share common metadata between many packages.</para></listitem>
 <varname>B</varname> = "pre${A}post"</screen></para>
                <para>This results in <varname>A</varname> containing <literal>aval</literal> and <varname>B</varname> containing <literal>preavalpost</literal>.</para>
            </section>
+            <section>
+                <title>Setting a default value (?=)</title>
+                <para><screen><varname>A</varname> ?= "aval"</screen></para>
+                <para>If <varname>A</varname> is set before the above is called, it will retain it's previous value. If <varname>A</varname> is unset prior to the above call, <varname>A</varname> will be set to <literal>aval</literal>.  Note that this assignment is immediate, so if there are multiple ?= assignments to a single variable, the first of those will be used.</para>
+            </section>
+            <section>
+                <title>Setting a default value (??=)</title>
+                <para><screen><varname>A</varname> ??= "somevalue"</screen></para>
+                <para><screen><varname>A</varname> ??= "someothervalue"</screen></para>
+                <para>If <varname>A</varname> is set before the above, it will retain that value.  If <varname>A</varname> is unset prior to the above, <varname>A</varname> will be set to <literal>someothervalue</literal>.  This is a lazy version of ??=, in that the assignment does not occur until the end of the parsing process, so that the last, rather than the first, ??= assignment to a given variable will be used.</para>
+            </section>
            <section>
                <title>Immediate variable expansion (:=)</title>
                <para>:= results in a variable's contents being expanded immediately, rather than when the variable is actually used.</para>
@@ -119,7 +130,7 @@ will be introduced.</para>
            </section>
            <section>
                <title>Conditional metadata set</title>
-                <para>OVERRIDES is a <quote>:</quote> seperated variable containing each item you want to satisfy conditions.  So, if you have a variable which is conditional on <quote>arm</quote>, and <quote>arm</quote> is in OVERRIDES, then the <quote>arm</quote> specific version of the variable is used rather than the non-conditional version.  Example:</para>
+                <para>OVERRIDES is a <quote>:</quote> separated variable containing each item you want to satisfy conditions.  So, if you have a variable which is conditional on <quote>arm</quote>, and <quote>arm</quote> is in OVERRIDES, then the <quote>arm</quote> specific version of the variable is used rather than the non-conditional version.  Example:</para>
                <para><screen><varname>OVERRIDES</varname> = "architecture:os:machine"
 <varname>TEST</varname> = "defaultvalue"
 <varname>TEST_os</varname> = "osspecificvalue"
@@ -184,7 +195,7 @@ include</literal> directive.</para>
            <section>
                <title>Inheritance</title>
                <para><emphasis>NOTE:</emphasis> This is only supported in .bb and .bbclass files.</para>
-                <para>The <literal>inherit</literal> directive is a means of specifying what classes of functionality your .bb requires.  It is a rudamentary form of inheritence.  For example, you can easily abstract out the tasks involved in building a package that uses autoconf and automake, and put that into a bbclass for your packages to make use of.  A given bbclass is located by searching for classes/filename.oeclass in <envar>BBPATH</envar>, where filename is what you inherited.</para>
+                <para>The <literal>inherit</literal> directive is a means of specifying what classes of functionality your .bb requires.  It is a rudimentary form of inheritance.  For example, you can easily abstract out the tasks involved in building a package that uses autoconf and automake, and put that into a bbclass for your packages to make use of.  A given bbclass is located by searching for classes/filename.oeclass in <envar>BBPATH</envar>, where filename is what you inherited.</para>
            </section>
            <section>
                <title>Tasks</title>
@@ -204,19 +215,29 @@ addtask printdate before do_build</screen></para>
                <para>BitBake allows to install event handlers.  Events are triggered at certain points during operation, such as, the beginning of operation against a given .bb, the start of a given task, task failure, task success, et cetera.  The intent was to make it easy to do things like email notifications on build failure.</para>
                <para><screen>addhandler myclass_eventhandler
 python myclass_eventhandler() {
-    from bb.event import NotHandled, getName
+    from bb.event import getName
    from bb import data

-    print "The name of the Event is %s" % getName(e)
-    print "The file we run for is %s" % data.getVar('FILE', e.data, True)
-
-    return NotHandled
+    print("The name of the Event is %s" % getName(e))
+    print("The file we run for is %s" % data.getVar('FILE', e.data, True))
 }
 </screen></para><para>
 This event handler gets called every time an event is triggered. A global variable <varname>e</varname> is defined. <varname>e</varname>.data contains an instance of bb.data. With the getName(<varname>e</varname>)
 method one can get the name of the triggered event.</para><para>The above event handler prints the name
 of the event and the content of the <varname>FILE</varname> variable.</para>
            </section>
+            <section>
+                <title>Variants</title>
+                <para>Two Bitbake features exist to facilitate the creation of multiple buildable incarnations from a single recipe file.</para>
+                <para>The first is <varname>BBCLASSEXTEND</varname>.  This variable is a space separated list of classes to utilize to "extend" the recipe for each variant.  As an example, setting <screen>BBCLASSEXTEND = "native"</screen> results in a second incarnation of the current recipe being available.  This second incarantion will have the "native" class inherited.</para>
+                <para>The second feature is <varname>BBVERSIONS</varname>.  This variable allows a single recipe to be able to build multiple versions of a project from a single recipe file, and allows you to specify conditional metadata (using the <varname>OVERRIDES</varname> mechanism) for a single version, or an optionally named range of versions:</para>
+                <para><screen>BBVERSIONS = "1.0 2.0 git"
+SRC_URI_git = "git://someurl/somepath.git"</screen></para>
+                <para><screen>BBVERSIONS = "1.0.[0-6]:1.0.0+ \
+              1.0.[7-9]:1.0.7+"
+SRC_URI_append_1.0.7+ = "file://some_patch_which_the_new_versions_need.patch;patch=1"</screen></para>
+                <para>Note that the name of the range will default to the original version of the recipe, so given OE, a recipe file of foo_1.0.0+.bb will default the name of its versions to 1.0.0+.  This is useful, as the range name is not only placed into overrides, it's also made available for the metadata to use in the form of the <varname>BPV</varname> variable, for use in file:// search paths (<varname>FILESPATH</varname>).</para>
+            </section>
        </section>
        <section>
            <title>Dependency Handling</title>
@@ -258,16 +279,18 @@ of the event and the content of the <varname>FILE</varname> variable.</para>
            <title>Parsing</title>
            <section>
                <title>Configuration Files</title>
-                <para>The first of the classifications of metadata in BitBake is configuration metadata.  This metadata is global, and therefore affects <emphasis>all</emphasis> packages and tasks which are executed.  Currently, BitBake has hardcoded knowledge of a single configuration file.  It expects to find 'conf/bitbake.conf' somewhere in the user specified <envar>BBPATH</envar>.  That configuration file generally has include directives to pull in any other metadata (generally files specific to architecture, machine, <emphasis>local</emphasis> and so on.</para>
+                <para>The first of the classifications of metadata in BitBake is configuration metadata.  This metadata is global, and therefore affects <emphasis>all</emphasis> packages and tasks which are executed.</para>
+                <para>Bitbake will first search the current working directory for an optional "conf/bblayers.conf" configuration file. This file is expected to contain a BBLAYERS variable which is a space delimited list of 'layer' directories. For each directory in this list a "conf/layer.conf" file will be searched for and parsed with the LAYERDIR variable being set to the directory where the layer was found. The idea is these files will setup BBPATH and other variables correctly for a given build directory automatically for the user.</para>
+                <para>Bitbake will then expect to find 'conf/bitbake.conf' somewhere in the user specified <envar>BBPATH</envar>.  That configuration file generally has include directives to pull in any other metadata (generally files specific to architecture, machine, <emphasis>local</emphasis> and so on.</para>
                <para>Only variable definitions and include directives are allowed in .conf files.</para>
            </section>
            <section>
                <title>Classes</title>
-                <para>BitBake classes are our rudamentary inheritence mechanism.  As briefly mentioned in the metadata introduction, they're parsed when an <literal>inherit</literal> directive is encountered, and they are located in classes/ relative to the dirs in <envar>BBPATH</envar>.</para>
+                <para>BitBake classes are our rudimentary inheritance mechanism.  As briefly mentioned in the metadata introduction, they're parsed when an <literal>inherit</literal> directive is encountered, and they are located in classes/ relative to the dirs in <envar>BBPATH</envar>.</para>
            </section>
            <section>
                <title>.bb Files</title>
-                <para>A BitBake (.bb) file is a logical unit of tasks to be executed.  Normally this is a package to be built.  Inter-.bb dependencies are obeyed.  The files themselves are located via the <varname>BBFILES</varname> variable, which is set to a space seperated list of .bb files, and does handle wildcards.</para>
+                <para>A BitBake (.bb) file is a logical unit of tasks to be executed.  Normally this is a package to be built.  Inter-.bb dependencies are obeyed.  The files themselves are located via the <varname>BBFILES</varname> variable, which is set to a space separated list of .bb files, and does handle wildcards.</para>
            </section>
        </section>
    </chapter>
@@ -293,9 +316,9 @@ a per URI parameters separated by a <quote>;</quote> consisting of a key and a v

        <section>
            <title>CVS File Fetcher</title>
-            <para>The URN for the CVS Fetcher is <emphasis>cvs</emphasis>. This Fetcher honors the variables <varname>DL_DIR</varname>, <varname>SRCDATE</varname>, <varname>FETCHCOMMAND_cvs</varname>, <varname>UPDATECOMMAND_cvs</varname>. <varname>DL_DIRS</varname> specifies where a temporary checkout is saved, <varname>SRCDATE</varname> specifies which date to use when doing the fetching (the special value of "now" will cause the checkout to be updated on every build), <varname>FETCHCOMMAND</varname> and <varname>UPDATECOMMAND</varname> specify which executables should be used when doing the CVS checkout or update.
+            <para>The URN for the CVS Fetcher is <emphasis>cvs</emphasis>. This Fetcher honors the variables <varname>DL_DIR</varname>, <varname>SRCDATE</varname>, <varname>FETCHCOMMAND_cvs</varname>, <varname>UPDATECOMMAND_cvs</varname>. <varname>DL_DIR</varname> specifies where a temporary checkout is saved, <varname>SRCDATE</varname> specifies which date to use when doing the fetching (the special value of "now" will cause the checkout to be updated on every build), <varname>FETCHCOMMAND</varname> and <varname>UPDATECOMMAND</varname> specify which executables should be used when doing the CVS checkout or update.
            </para>
-            <para>The supported Parameters are <varname>module</varname>, <varname>tag</varname>, <varname>date</varname>, <varname>method</varname>, <varname>localdir</varname>, <varname>rsh</varname>. The <varname>module</varname> specifies which module to check out, the <varname>tag</varname> describes which CVS TAG should be used for the checkout by default the TAG is empty. A <varname>date</varname> can be specified to override the SRCDATE of the configuration to checkout a specific date.  The special value of "now" will cause the checkout to be updated on every build.<varname>method</varname> is by default <emphasis>pserver</emphasis>, if <emphasis>ext</emphasis> is used the <varname>rsh</varname> parameter will be evaluated and <varname>CVS_RSH</varname> will be set. Finally <varname>localdir</varname> is used to checkout into a special directory relative to <varname>CVSDIR></varname>.
+            <para>The supported Parameters are <varname>module</varname>, <varname>tag</varname>, <varname>date</varname>, <varname>method</varname>, <varname>localdir</varname>, <varname>rsh</varname>. The <varname>module</varname> specifies which module to check out, the <varname>tag</varname> describes which CVS TAG should be used for the checkout by default the TAG is empty. A <varname>date</varname> can be specified to override the SRCDATE of the configuration to checkout a specific date.  The special value of "now" will cause the checkout to be updated on every build.<varname>method</varname> is by default <emphasis>pserver</emphasis>, if <emphasis>ext</emphasis> is used the <varname>rsh</varname> parameter will be evaluated and <varname>CVS_RSH</varname> will be set. Finally <varname>localdir</varname> is used to checkout into a special directory relative to <varname>CVSDIR</varname>.
 <screen><varname>SRC_URI</varname> = "cvs://CVSROOT;module=mymodule;tag=some-version;method=ext"
 <varname>SRC_URI</varname> = "cvs://CVSROOT;module=mymodule;date=20060126;localdir=usethat"
 </screen>
@@ -352,15 +375,7 @@ will be tried first when fetching a file if that fails the actual file will be t


    <chapter>
-        <title>Commands</title>
-        <section>
-            <title>bbread</title>
-            <para>bbread is a command for displaying BitBake metadata.  When run with no arguments, it has the core parse 'conf/bitbake.conf', as located in BBPATH, and displays that.  If you supply a file on the commandline, such as a .bb, then it parses that afterwards, using the aforementioned configuration metadata.</para>
-        <para><emphasis>NOTE: the stand a lone bbread command was removed. Instead of bbread use bitbake -e.
-        </emphasis></para>
-        </section>
-        <section>
-            <title>bitbake</title>
+        <title>The bitbake command</title>
            <section>
                <title>Introduction</title>
                <para>bitbake is the primary command in the system.  It facilitates executing tasks in a single .bb file, or executing a given task on a set of multiple .bb files, accounting for interdependencies amongst them.</para>
@@ -372,7 +387,7 @@ will be tried first when fetching a file if that fails the actual file will be t
 usage: bitbake [options] [package ...]

 Executes the specified task (default is 'build') for a given set of BitBake files.
-It expects that BBFILES is defined, which is a space seperated list of files to
+It expects that BBFILES is defined, which is a space separated list of files to
 be executed.  BBFILES does support wildcards.
 Default BBFILES are the .bb files in the current directory.

@@ -394,7 +409,7 @@ options:
                        it depends on, i.e. 'compile' does not implicitly call
                        stage for the dependencies (IOW: use only if you know
                        what you are doing). Depending on the base.bbclass a
-                        listtasks tasks is defined and will show available
+                        listtasks task is defined and will show available
                        tasks
  -r FILE, --read=FILE  read the specified file before bitbake.conf
  -v, --verbose         output more chit-chat to the terminal
@@ -415,6 +430,8 @@ options:
                        the graph more appealing
  -l DEBUG_DOMAINS, --log-domains=DEBUG_DOMAINS
                        Show debug logging for the specified logging domains
+  -P, --profile         profile the command and print a report
+

 </screen>
                </para>
@@ -461,12 +478,12 @@ Two files will be written into the current working directory, <emphasis>depends.
            </section>
            <section>
                <title>Metadata</title>
-                <para>As you may have seen in the usage information, or in the information about .bb files, the BBFILES variable is how the bitbake tool locates its files.  This variable is a space seperated list of files that are available, and supports wildcards.
+                <para>As you may have seen in the usage information, or in the information about .bb files, the BBFILES variable is how the bitbake tool locates its files.  This variable is a space separated list of files that are available, and supports wildcards.
                <example>
                    <title>Setting BBFILES</title>
                    <programlisting><varname>BBFILES</varname> = "/path/to/bbfiles/*.bb"</programlisting>
                </example></para>
-                <para>With regard to dependencies, it expects the .bb to define a <varname>DEPENDS</varname> variable, which contains a space seperated list of <quote>package names</quote>, which themselves are the <varname>PN</varname> variable.  The <varname>PN</varname> variable is, in general, by default, set to a component of the .bb filename.</para>
+                <para>With regard to dependencies, it expects the .bb to define a <varname>DEPENDS</varname> variable, which contains a space separated list of <quote>package names</quote>, which themselves are the <varname>PN</varname> variable.  The <varname>PN</varname> variable is, in general, by default, set to a component of the .bb filename.</para>
                <example>
                    <title>Depending on another .bb</title>
                    <para>a.bb:
@@ -513,6 +530,5 @@ BBFILE_PRIORITY_upstream = "5"
 BBFILE_PRIORITY_local = "10"</screen>
                </example>
            </section>
-        </section>
    </chapter>
 </book>
--- a/bitbake/lib/bb/COW.py
+++ b/bitbake/lib/bb/COW.py
@@ -3,7 +3,7 @@
 #
 # This is a copy on write dictionary and set which abuses classes to try and be nice and fast.
 #
-# Copyright (C) 2006 Tim Amsell 
+# Copyright (C) 2006 Tim Amsell
 #
 # This program is free software; you can redistribute it and/or modify
 # it under the terms of the GNU General Public License version 2 as
@@ -18,31 +18,31 @@
 # with this program; if not, write to the Free Software Foundation, Inc.,
 # 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 #
-#Please Note: 
+#Please Note:
 # Be careful when using mutable types (ie Dict and Lists) - operations involving these are SLOW.
 # Assign a file to __warn__ to get warnings about slow operations.
 #

-from inspect import getmro
-
+from __future__ import print_function
 import copy
-import types, sets
-types.ImmutableTypes = tuple([ \
-    types.BooleanType, \
-    types.ComplexType, \
-    types.FloatType, \
-    types.IntType, \
-    types.LongType, \
-    types.NoneType, \
-    types.TupleType, \
-    sets.ImmutableSet] + \
-    list(types.StringTypes))
+import types
+ImmutableTypes = (
+    types.NoneType,
+    bool,
+    complex,
+    float,
+    int,
+    long,
+    tuple,
+    frozenset,
+    basestring
+)

 MUTABLE = "__mutable__"

 class COWMeta(type):
    pass
- 
+
 class COWDictMeta(COWMeta):
    __warn__ = False
    __hasmutable__ = False
@@ -61,12 +61,12 @@ class COWDictMeta(COWMeta):
    __call__ = cow

    def __setitem__(cls, key, value):
-        if not isinstance(value, types.ImmutableTypes):
+        if not isinstance(value, ImmutableTypes):
            if not isinstance(value, COWMeta):
                cls.__hasmutable__ = True
            key += MUTABLE
        setattr(cls, key, value)
-    
+
    def __getmutable__(cls, key, readonly=False):
        nkey = key + MUTABLE
        try:
@@ -79,10 +79,10 @@ class COWDictMeta(COWMeta):
            return value

        if not cls.__warn__ is False and not isinstance(value, COWMeta):
-            print >> cls.__warn__, "Warning: Doing a copy because %s is a mutable type." % key
+            print("Warning: Doing a copy because %s is a mutable type." % key, file=cls.__warn__)
        try:
            value = value.copy()
-        except AttributeError, e:
+        except AttributeError as e:
            value = copy.copy(value)
        setattr(cls, nkey, value)
        return value
@@ -100,13 +100,13 @@ class COWDictMeta(COWMeta):
                value = getattr(cls, key)
            except AttributeError:
                value = cls.__getmutable__(key, readonly)
-            
-            # This is for values which have been deleted 
+
+            # This is for values which have been deleted
            if value is cls.__marker__:
                raise AttributeError("key %s does not exist." % key)

            return value
-        except AttributeError, e:
+        except AttributeError as e:
            if not default is cls.__getmarker__:
                return default

@@ -120,6 +120,9 @@ class COWDictMeta(COWMeta):
            key += MUTABLE
        delattr(cls, key)

+    def __contains__(cls, key):
+        return cls.has_key(key)
+
    def has_key(cls, key):
        value = cls.__getreadonly__(key, cls.__marker__)
        if value is cls.__marker__:
@@ -129,7 +132,7 @@ class COWDictMeta(COWMeta):
    def iter(cls, type, readonly=False):
        for key in dir(cls):
            if key.startswith("__"):
-                    continue
+                continue

            if key.endswith(MUTABLE):
                key = key[:-len(MUTABLE)]
@@ -155,11 +158,11 @@ class COWDictMeta(COWMeta):
        return cls.iter("keys")
    def itervalues(cls, readonly=False):
        if not cls.__warn__ is False and cls.__hasmutable__ and readonly is False:
-            print >> cls.__warn__, "Warning: If you arn't going to change any of the values call with True."
+            print("Warning: If you arn't going to change any of the values call with True.", file=cls.__warn__)
        return cls.iter("values", readonly)
    def iteritems(cls, readonly=False):
        if not cls.__warn__ is False and cls.__hasmutable__ and readonly is False:
-            print >> cls.__warn__, "Warning: If you arn't going to change any of the values call with True."
+            print("Warning: If you arn't going to change any of the values call with True.", file=cls.__warn__)
        return cls.iter("items", readonly)

 class COWSetMeta(COWDictMeta):
@@ -178,13 +181,13 @@ class COWSetMeta(COWDictMeta):

    def remove(cls, value):
        COWDictMeta.__delitem__(cls, repr(hash(value)))
- 
+
    def __in__(cls, value):
        return COWDictMeta.has_key(repr(hash(value)))

    def iterkeys(cls):
        raise TypeError("sets don't have keys")
-    
+
    def iteritems(cls):
        raise TypeError("sets don't have 'items'")

@@ -201,120 +204,120 @@ if __name__ == "__main__":
    import sys
    COWDictBase.__warn__ = sys.stderr
    a = COWDictBase()
-    print "a", a
+    print("a", a)

    a['a'] = 'a'
    a['b'] = 'b'
    a['dict'] = {}

    b = a.copy()
-    print "b", b
+    print("b", b)
    b['c'] = 'b'

-    print
+    print()

-    print "a", a
+    print("a", a)
    for x in a.iteritems():
-        print x
-    print "--"
-    print "b", b
+        print(x)
+    print("--")
+    print("b", b)
    for x in b.iteritems():
-        print x
-    print
+        print(x)
+    print()

    b['dict']['a'] = 'b'
    b['a'] = 'c'

-    print "a", a
+    print("a", a)
    for x in a.iteritems():
-        print x
-    print "--"
-    print "b", b
+        print(x)
+    print("--")
+    print("b", b)
    for x in b.iteritems():
-        print x
-    print
+        print(x)
+    print()

    try:
        b['dict2']
-    except KeyError, e:
-        print "Okay!"
+    except KeyError as e:
+        print("Okay!")

    a['set'] = COWSetBase()
    a['set'].add("o1")
    a['set'].add("o1")
    a['set'].add("o2")

-    print "a", a
+    print("a", a)
    for x in a['set'].itervalues():
-        print x
-    print "--"
-    print "b", b
+        print(x)
+    print("--")
+    print("b", b)
    for x in b['set'].itervalues():
-        print x
-    print
+        print(x)
+    print()

    b['set'].add('o3')

-    print "a", a
+    print("a", a)
    for x in a['set'].itervalues():
-        print x
-    print "--"
-    print "b", b
+        print(x)
+    print("--")
+    print("b", b)
    for x in b['set'].itervalues():
-        print x
-    print
+        print(x)
+    print()

    a['set2'] = set()
    a['set2'].add("o1")
    a['set2'].add("o1")
    a['set2'].add("o2")

-    print "a", a
+    print("a", a)
    for x in a.iteritems():
-        print x
-    print "--"
-    print "b", b
+        print(x)
+    print("--")
+    print("b", b)
    for x in b.iteritems(readonly=True):
-        print x
-    print
+        print(x)
+    print()

    del b['b']
    try:
-        print b['b']
+        print(b['b'])
    except KeyError:
-        print "Yay! deleted key raises error"
+        print("Yay! deleted key raises error")

    if b.has_key('b'):
-        print "Boo!"
+        print("Boo!")
    else:
-        print "Yay - has_key with delete works!"
-    
-    print "a", a
+        print("Yay - has_key with delete works!")
+
+    print("a", a)
    for x in a.iteritems():
-        print x
-    print "--"
-    print "b", b
+        print(x)
+    print("--")
+    print("b", b)
    for x in b.iteritems(readonly=True):
-        print x
-    print
+        print(x)
+    print()

    b.__revertitem__('b')

-    print "a", a
+    print("a", a)
    for x in a.iteritems():
-        print x
-    print "--"
-    print "b", b
+        print(x)
+    print("--")
+    print("b", b)
    for x in b.iteritems(readonly=True):
-        print x
-    print
+        print(x)
+    print()

    b.__revertitem__('dict')
-    print "a", a
+    print("a", a)
    for x in a.iteritems():
-        print x
-    print "--"
-    print "b", b
+        print(x)
+    print("--")
+    print("b", b)
    for x in b.iteritems(readonly=True):
-        print x
-    print
+        print(x)
+    print()
--- a/bitbake/lib/bb/init.py
+++ b/bitbake/lib/bb/init.py
--- a/bitbake/lib/bb/build.py
+++ b/bitbake/lib/bb/build.py
@@ -25,25 +25,33 @@
 #
 #Based on functions from the base bb module, Copyright 2003 Holger Schurig

-from bb import data, fetch, event, mkdirhier, utils
-import bb, os
+from bb import data, event, mkdirhier, utils
+import bb, os, sys
+import bb.utils
+
+# When we execute a python function we'd like certain things
+# in all namespaces, hence we add them to __builtins__
+# If we do not do this and use the exec globals, they will
+# not be available to subfunctions.
+__builtins__['bb'] = bb
+__builtins__['os'] = os

 # events
 class FuncFailed(Exception):
-    """Executed function failed"""
-
-class EventException(Exception):
-    """Exception which is associated with an Event."""
-
-    def __init__(self, msg, event):
-        self.args = msg, event
+    """
+    Executed function failed
+    First parameter a message
+    Second paramter is a logfile (optional)
+    """

 class TaskBase(event.Event):
    """Base class for task events"""

    def __init__(self, t, d ):
        self._task = t
-        event.Event.__init__(self, d)
+        self._package = bb.data.getVar("PF", d, 1)
+        event.Event.__init__(self)
+        self._message = "package %s: task %s: %s" % (bb.data.getVar("PF", d, 1), t, bb.event.getName(self)[4:])

    def getTask(self):
        return self._task
@@ -61,8 +69,12 @@ class TaskSucceeded(TaskBase):

 class TaskFailed(TaskBase):
    """Task execution failed"""
+    def __init__(self, msg, logfile, t, d ):
+        self.logfile = logfile
+        self.msg = msg
+        TaskBase.__init__(self, t, d)

-class InvalidTask(TaskBase):
+class TaskInvalid(TaskBase):
    """Invalid Task"""

 # functions
@@ -72,53 +84,97 @@ def exec_func(func, d, dirs = None):

    body = data.getVar(func, d)
    if not body:
+        bb.warn("Function %s doesn't exist" % func)
        return

-    if not dirs:
-        dirs = (data.getVarFlag(func, 'dirs', d) or "").split()
-    for adir in dirs:
-        adir = data.expand(adir, d)
-        mkdirhier(adir)
+    flags = data.getVarFlags(func, d)
+    for item in ['deps', 'check', 'interactive', 'python', 'cleandirs', 'dirs', 'lockfiles', 'fakeroot', 'task']:
+        if not item in flags:
+            flags[item] = None

-    if len(dirs) > 0:
+    ispython = flags['python']
+
+    cleandirs = flags['cleandirs']
+    if cleandirs:
+        for cdir in data.expand(cleandirs, d).split():
+            os.system("rm -rf %s" % cdir)
+
+    if dirs is None:
+        dirs = flags['dirs']
+        if dirs:
+            dirs = data.expand(dirs, d).split()
+
+    if dirs:
+        for adir in dirs:
+            bb.utils.mkdirhier(adir)
        adir = dirs[-1]
    else:
        adir = data.getVar('B', d, 1)

-    adir = data.expand(adir, d)
-
+    # Save current directory
    try:
        prevdir = os.getcwd()
    except OSError:
-        prevdir = data.expand('${TOPDIR}', d)
+        prevdir = data.getVar('TOPDIR', d, True)
+
+    # Setup scriptfile
+    t = data.getVar('T', d, 1)
+    if not t:
+        raise SystemExit("T variable not set, unable to build")
+    bb.utils.mkdirhier(t)
+    runfile = "%s/run.%s.%s" % (t, func, str(os.getpid()))
+    logfile = d.getVar("BB_LOGFILE", True)
+
+    # Change to correct directory (if specified)
    if adir and os.access(adir, os.F_OK):
        os.chdir(adir)

-    if data.getVarFlag(func, "python", d):
-        exec_func_python(func, d)
-    else:
-        exec_func_shell(func, d)
+    locks = []
+    lockfiles = flags['lockfiles']
+    if lockfiles:
+        for lock in data.expand(lockfiles, d).split():
+            locks.append(bb.utils.lockfile(lock))

-    if os.path.exists(prevdir):
-        os.chdir(prevdir)
+    try:
+        # Run the function
+        if ispython:
+            exec_func_python(func, d, runfile, logfile)
+        else:
+            exec_func_shell(func, d, runfile, logfile, flags)

-def exec_func_python(func, d):
+        # Restore original directory
+        try:
+            os.chdir(prevdir)
+        except:
+            pass
+
+    finally:
+
+        # Unlock any lockfiles
+        for lock in locks:
+            bb.utils.unlockfile(lock)
+
+def exec_func_python(func, d, runfile, logfile):
    """Execute a python BB 'function'"""
-    import re, os

-    tmp  = "def " + func + "():\n%s" % data.getVar(func, d)
-    tmp += '\n' + func + '()'
-    comp = utils.better_compile(tmp, func, bb.data.getVar('FILE', d, 1) )
-    prevdir = os.getcwd()
-    g = {} # globals
-    g['bb'] = bb
-    g['os'] = os
-    g['d'] = d
-    utils.better_exec(comp,g,tmp, bb.data.getVar('FILE',d,1))
-    if os.path.exists(prevdir):
-        os.chdir(prevdir)
+    bbfile = bb.data.getVar('FILE', d, 1)
+    tmp  = "def " + func + "(d):\n%s" % data.getVar(func, d)
+    tmp += '\n' + func + '(d)'

-def exec_func_shell(func, d):
+    f = open(runfile, "w")
+    f.write(tmp)
+    comp = utils.better_compile(tmp, func, bbfile)
+    try:
+        utils.better_exec(comp, {"d": d}, tmp, bbfile)
+    except:
+        (t, value, tb) = sys.exc_info()
+
+        if t in [bb.parse.SkipPackage, bb.build.FuncFailed]:
+            raise
+        raise FuncFailed("Function %s failed" % func, logfile)
+
+
+def exec_func_shell(func, d, runfile, logfile, flags):
    """Execute a shell BB 'function' Returns true if execution was successful.

    For this, it creates a bash shell script in the tmp dectory, writes the local
@@ -128,240 +184,187 @@ def exec_func_shell(func, d):
    of the directories you need created prior to execution.  The last
    item in the list is where we will chdir/cd to.
    """
-    import sys

-    deps = data.getVarFlag(func, 'deps', d)
-    check = data.getVarFlag(func, 'check', d)
-    interact = data.getVarFlag(func, 'interactive', d)
+    deps = flags['deps']
+    check = flags['check']
    if check in globals():
        if globals()[check](func, deps):
            return

-    global logfile
-    t = data.getVar('T', d, 1)
-    if not t:
-        return 0
-    mkdirhier(t)
-    logfile = "%s/log.%s.%s" % (t, func, str(os.getpid()))
-    runfile = "%s/run.%s.%s" % (t, func, str(os.getpid()))
-
    f = open(runfile, "w")
    f.write("#!/bin/sh -e\n")
    if bb.msg.debug_level['default'] > 0: f.write("set -x\n")
-    data.emit_env(f, d)
+    data.emit_func(func, f, d)

-    f.write("cd '%s'\n" % os.getcwd())
+    f.write("cd %s\n" % os.getcwd())
    if func: f.write("%s\n" % func)
    f.close()
    os.chmod(runfile, 0775)
    if not func:
-        bb.msg.error(bb.msg.domain.Build, "Function not specified")
-        raise FuncFailed()
-
-    # open logs
-    si = file('/dev/null', 'r')
-    try:
-        if bb.msg.debug_level['default'] > 0:
-            so = os.popen("tee \"%s\"" % logfile, "w")
-        else:
-            so = file(logfile, 'w')
-    except OSError, e:
-        bb.msg.error(bb.msg.domain.Build, "opening log file: %s" % e)
-        pass
-
-    se = so
-
-    if not interact:
-        # dup the existing fds so we dont lose them
-        osi = [os.dup(sys.stdin.fileno()), sys.stdin.fileno()]
-        oso = [os.dup(sys.stdout.fileno()), sys.stdout.fileno()]
-        ose = [os.dup(sys.stderr.fileno()), sys.stderr.fileno()]
-
-        # replace those fds with our own
-        os.dup2(si.fileno(), osi[1])
-        os.dup2(so.fileno(), oso[1])
-        os.dup2(se.fileno(), ose[1])
+        raise FuncFailed("Function not specified for exec_func_shell")

    # execute function
-    prevdir = os.getcwd()
-    if data.getVarFlag(func, "fakeroot", d):
-        maybe_fakeroot = "PATH=\"%s\" fakeroot " % bb.data.getVar("PATH", d, 1)
-    else:
-        maybe_fakeroot = ''
+    if flags['fakeroot'] and not flags['task']:
+        bb.fatal("Function %s specifies fakeroot but isn't a task?!" % func)
+
    lang_environment = "LC_ALL=C "
-    ret = os.system('%s%ssh -e "%s"' % (lang_environment, maybe_fakeroot, runfile))
-    try:
-        os.chdir(prevdir)
-    except:
-        pass
+    ret = os.system('%ssh -e %s' % (lang_environment, runfile))

-    if not interact:
-        # restore the backups
-        os.dup2(osi[0], osi[1])
-        os.dup2(oso[0], oso[1])
-        os.dup2(ose[0], ose[1])
-
-        # close our logs
-        si.close()
-        so.close()
-        se.close()
-
-        # close the backup fds
-        os.close(osi[0])
-        os.close(oso[0])
-        os.close(ose[0])
-
-    if ret==0:
-        if bb.msg.debug_level['default'] > 0:
-            os.remove(runfile)
-#            os.remove(logfile)
+    if ret == 0:
        return
-    else:
-        bb.msg.error(bb.msg.domain.Build, "function %s failed" % func)
-        if data.getVar("BBINCLUDELOGS", d):
-            bb.msg.error(bb.msg.domain.Build, "log data follows (%s)" % logfile)
-            number_of_lines = data.getVar("BBINCLUDELOGS_LINES", d)
-            if number_of_lines:
-                os.system('tail -n%s %s' % (number_of_lines, logfile))
-            else:
-                f = open(logfile, "r")
-                while True:
-                    l = f.readline()
-                    if l == '':
-                        break
-                    l = l.rstrip()
-                    print '| %s' % l
-                f.close()
-        else:
-            bb.msg.error(bb.msg.domain.Build, "see log in %s" % logfile)
-        raise FuncFailed( logfile )
+
+    raise FuncFailed("function %s failed" % func, logfile)


-def exec_task(task, d):
+def exec_task(fn, task, d):
    """Execute an BB 'task'

       The primary difference between executing a task versus executing
       a function is that a task exists in the task digraph, and therefore
       has dependencies amongst other tasks."""

-    # check if the task is in the graph..
-    task_graph = data.getVar('_task_graph', d)
-    if not task_graph:
-        task_graph = bb.digraph()
-        data.setVar('_task_graph', task_graph, d)
-    task_cache = data.getVar('_task_cache', d)
-    if not task_cache:
-        task_cache = []
-        data.setVar('_task_cache', task_cache, d)
-    if not task_graph.hasnode(task):
-        raise EventException("Missing node in task graph", InvalidTask(task, d))
-
-    # check whether this task needs executing..
-    if stamp_is_current(task, d):
+    # Check whther this is a valid task
+    if not data.getVarFlag(task, 'task', d):
+        event.fire(TaskInvalid(task, d), d)
+        bb.msg.error(bb.msg.domain.Build, "No such task: %s" % task)
        return 1

-    # follow digraph path up, then execute our way back down
-    def execute(graph, item):
-        if data.getVarFlag(item, 'task', d):
-            if item in task_cache:
-                return 1
+    quieterr = False
+    if d.getVarFlag(task, "quieterrors") is not None:
+         quieterr = True

-            if task != item:
-                # deeper than toplevel, exec w/ deps
-                exec_task(item, d)
-                return 1
+    try:
+        bb.msg.debug(1, bb.msg.domain.Build, "Executing task %s" % task)
+        old_overrides = data.getVar('OVERRIDES', d, 0)
+        localdata = data.createCopy(d)
+        data.setVar('OVERRIDES', 'task-%s:%s' % (task[3:], old_overrides), localdata)
+        data.update_data(localdata)
+        data.expandKeys(localdata)
+        data.setVar('BB_FILENAME', fn, d)
+        data.setVar('BB_CURRENTTASK', task[3:], d)
+        event.fire(TaskStarted(task, localdata), localdata)
+
+        # Setup logfiles
+        t = data.getVar('T', d, 1)
+        if not t:
+            raise SystemExit("T variable not set, unable to build")
+        bb.utils.mkdirhier(t)
+        loglink = "%s/log.%s" % (t, task)
+        logfile = "%s/log.%s.%s" % (t, task, str(os.getpid()))
+        d.setVar("BB_LOGFILE", logfile)
+
+        # Even though the log file has not yet been opened, lets create the link
+        if loglink:
+            try:
+                os.remove(loglink)
+            except OSError as e:
+                pass

            try:
-                bb.msg.debug(1, bb.msg.domain.Build, "Executing task %s" % item)
-                old_overrides = data.getVar('OVERRIDES', d, 0)
-                localdata = data.createCopy(d)
-                data.setVar('OVERRIDES', 'task_%s:%s' % (item, old_overrides), localdata)
-                data.update_data(localdata)
-                event.fire(TaskStarted(item, localdata))
-                exec_func(item, localdata)
-                event.fire(TaskSucceeded(item, localdata))
-                task_cache.append(item)
-                data.setVar('_task_cache', task_cache, d)
-            except FuncFailed, reason:
-                bb.msg.note(1, bb.msg.domain.Build, "Task failed: %s" % reason )
-                failedevent = TaskFailed(item, d)
-                event.fire(failedevent)
-                raise EventException("Function failed in task: %s" % reason, failedevent)
+                os.symlink(logfile, loglink)
+            except OSError as e:
+                pass

-    if data.getVarFlag(task, 'dontrundeps', d):
-        execute(None, task)
-    else:
-        task_graph.walkdown(task, execute)
+        # Handle logfiles
+        si = file('/dev/null', 'r')
+        try:
+            so = file(logfile, 'w')
+        except OSError as e:
+            bb.msg.error(bb.msg.domain.Build, "opening log file: %s" % e)
+            pass
+        se = so

-    # make stamp, or cause event and raise exception
-    if not data.getVarFlag(task, 'nostamp', d):
-        make_stamp(task, d)
+        # Dup the existing fds so we dont lose them
+        osi = [os.dup(sys.stdin.fileno()), sys.stdin.fileno()]
+        oso = [os.dup(sys.stdout.fileno()), sys.stdout.fileno()]
+        ose = [os.dup(sys.stderr.fileno()), sys.stderr.fileno()]

-def extract_stamp_data(d, fn):
-    """
-    Extracts stamp data from d which is either a data dictonary (fn unset) 
-    or a dataCache entry (fn set). 
-    """
-    if fn:
-        return (d.task_queues[fn], d.stamp[fn], d.task_deps[fn])
-    task_graph = data.getVar('_task_graph', d)
-    if not task_graph:
-        task_graph = bb.digraph()
-        data.setVar('_task_graph', task_graph, d)
-    return (task_graph, data.getVar('STAMP', d, 1), None)
+        # Replace those fds with our own
+        os.dup2(si.fileno(), osi[1])
+        os.dup2(so.fileno(), oso[1])
+        os.dup2(se.fileno(), ose[1])
+
+        # Since we've remapped stdout and stderr, its safe for log messages to be printed there now
+        # exec_func can nest so we have to save state
+        origstdout = bb.event.useStdout
+        bb.event.useStdout = True
+
+
+        prefuncs = (data.getVarFlag(task, 'prefuncs', localdata) or "").split()
+        for func in prefuncs:
+            exec_func(func, localdata)
+        exec_func(task, localdata)
+        postfuncs = (data.getVarFlag(task, 'postfuncs', localdata) or "").split()
+        for func in postfuncs:
+            exec_func(func, localdata)
+
+        event.fire(TaskSucceeded(task, localdata), localdata)
+
+        # make stamp, or cause event and raise exception
+        if not data.getVarFlag(task, 'nostamp', d) and not data.getVarFlag(task, 'selfstamp', d):
+            make_stamp(task, d)
+
+    except FuncFailed as message:
+        # Try to extract the optional logfile
+        try:
+            (msg, logfile) = message
+        except:
+            logfile = None
+            msg = message
+        if not quieterr:
+            bb.msg.error(bb.msg.domain.Build, "Task failed: %s" % message )
+            failedevent = TaskFailed(msg, logfile, task, d)
+            event.fire(failedevent, d)
+        return 1
+
+    except Exception:
+        from traceback import format_exc
+        if not quieterr:
+            bb.msg.error(bb.msg.domain.Build, "Build of %s failed" % (task))
+            bb.msg.error(bb.msg.domain.Build, format_exc())
+            failedevent = TaskFailed("Task Failed", None, task, d)
+            event.fire(failedevent, d)
+        return 1
+    finally:
+        sys.stdout.flush()
+        sys.stderr.flush()
+
+        bb.event.useStdout = origstdout
+
+        # Restore the backup fds
+        os.dup2(osi[0], osi[1])
+        os.dup2(oso[0], oso[1])
+        os.dup2(ose[0], ose[1])
+
+        # Close our logs
+        si.close()
+        so.close()
+        se.close()
+
+        if logfile and os.path.exists(logfile) and os.path.getsize(logfile) == 0:
+            bb.msg.debug(2, bb.msg.domain.Build, "Zero size logfile %s, removing" % logfile)
+            os.remove(logfile)
+            try:
+               os.remove(loglink)
+            except OSError as e:
+               pass
+
+        # Close the backup fds
+        os.close(osi[0])
+        os.close(oso[0])
+        os.close(ose[0])
+
+    return 0

 def extract_stamp(d, fn):
    """
-    Extracts stamp format which is either a data dictonary (fn unset) 
-    or a dataCache entry (fn set). 
+    Extracts stamp format which is either a data dictionary (fn unset)
+    or a dataCache entry (fn set).
    """
    if fn:
        return d.stamp[fn]
    return data.getVar('STAMP', d, 1)

-def stamp_is_current(task, d, file_name = None, checkdeps = 1):
-    """
-    Check status of a given task's stamp. 
-    Returns 0 if it is not current and needs updating.
-    (d can be a data dict or dataCache)
-    """
-
-    (task_graph, stampfn, taskdep) = extract_stamp_data(d, file_name)
-
-    if not stampfn:
-        return 0
-
-    stampfile = "%s.%s" % (stampfn, task)
-    if not os.access(stampfile, os.F_OK):
-        return 0
-
-    if checkdeps == 0:
-        return 1
-
-    import stat
-    tasktime = os.stat(stampfile)[stat.ST_MTIME]
-
-    _deps = []
-    def checkStamp(graph, task):
-        # check for existance
-        if file_name:
-            if 'nostamp' in taskdep and task in taskdep['nostamp']:
-                return 1
-        else:
-            if data.getVarFlag(task, 'nostamp', d):
-                return 1
-
-        if not stamp_is_current(task, d, file_name, 0						):
-            return 0
-
-        depfile = "%s.%s" % (stampfn, task)
-        deptime = os.stat(depfile)[stat.ST_MTIME]
-        if deptime > tasktime:
-            return 0
-        return 1
-
-    return task_graph.walkdown(task, checkStamp)
-
 def stamp_internal(task, d, file_name):
    """
    Internal stamp helper function
@@ -373,7 +376,7 @@ def stamp_internal(task, d, file_name):
    if not stamp:
        return
    stamp = "%s.%s" % (stamp, task)
-    mkdirhier(os.path.dirname(stamp))
+    bb.utils.mkdirhier(os.path.dirname(stamp))
    # Remove the file and recreate to force timestamp
    # change on broken NFS filesystems
    if os.access(stamp, os.F_OK):
@@ -397,35 +400,41 @@ def del_stamp(task, d, file_name = None):
    """
    stamp_internal(task, d, file_name)

-def add_task(task, deps, d):
-    task_graph = data.getVar('_task_graph', d)
-    if not task_graph:
-        task_graph = bb.digraph()
-    data.setVarFlag(task, 'task', 1, d)
-    task_graph.addnode(task, None)
-    for dep in deps:
-        if not task_graph.hasnode(dep):
-            task_graph.addnode(dep, None)
-        task_graph.addnode(task, dep)
-    # don't assume holding a reference
-    data.setVar('_task_graph', task_graph, d)
-
+def add_tasks(tasklist, d):
    task_deps = data.getVar('_task_deps', d)
    if not task_deps:
        task_deps = {}
-    def getTask(name):
-        deptask = data.getVarFlag(task, name, d)
-        if deptask:
-            deptask = data.expand(deptask, d)
+    if not 'tasks' in task_deps:
+        task_deps['tasks'] = []
+    if not 'parents' in task_deps:
+        task_deps['parents'] = {}
+
+    for task in tasklist:
+        task = data.expand(task, d)
+        data.setVarFlag(task, 'task', 1, d)
+
+        if not task in task_deps['tasks']:
+            task_deps['tasks'].append(task)
+
+        flags = data.getVarFlags(task, d)
+        def getTask(name):
            if not name in task_deps:
                task_deps[name] = {}
-            task_deps[name][task] = deptask
-    getTask('depends')
-    getTask('deptask')
-    getTask('rdeptask')
-    getTask('recrdeptask')
-    getTask('nostamp')
+            if name in flags:
+                deptask = data.expand(flags[name], d)
+                task_deps[name][task] = deptask
+        getTask('depends')
+        getTask('deptask')
+        getTask('rdeptask')
+        getTask('recrdeptask')
+        getTask('nostamp')
+        getTask('fakeroot')
+        task_deps['parents'][task] = []
+        for dep in flags['deps']:
+            dep = data.expand(dep, d)
+            task_deps['parents'][task].append(dep)

+    # don't assume holding a reference
    data.setVar('_task_deps', task_deps, d)

 def remove_task(task, kill, d):
@@ -433,22 +442,4 @@ def remove_task(task, kill, d):

       If kill is 1, also remove tasks that depend on this task."""

-    task_graph = data.getVar('_task_graph', d)
-    if not task_graph:
-        task_graph = bb.digraph()
-    if not task_graph.hasnode(task):
-        return
-
    data.delVarFlag(task, 'task', d)
-    ref = 1
-    if kill == 1:
-        ref = 2
-    task_graph.delnode(task, ref)
-    data.setVar('_task_graph', task_graph, d)
-
-def task_exists(task, d):
-    task_graph = data.getVar('_task_graph', d)
-    if not task_graph:
-        task_graph = bb.digraph()
-        data.setVar('_task_graph', task_graph, d)
-    return task_graph.hasnode(task)
--- a/bitbake/lib/bb/cache.py
+++ b/bitbake/lib/bb/cache.py
@@ -28,10 +28,9 @@
 # 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.


-import os, re
+import os
 import bb.data
 import bb.utils
-from sets import Set

 try:
    import cPickle as pickle
@@ -39,102 +38,147 @@ except ImportError:
    import pickle
    bb.msg.note(1, bb.msg.domain.Cache, "Importing cPickle failed. Falling back to a very slow implementation.")

-__cache_version__ = "126"
+__cache_version__ = "132"

 class Cache:
    """
    BitBake Cache implementation
    """
-    def __init__(self, cooker):
+    def __init__(self, data):


-        self.cachedir = bb.data.getVar("CACHE", cooker.configuration.data, True)
+        self.cachedir = bb.data.getVar("CACHE", data, True)
        self.clean = {}
+        self.checked = {}
        self.depends_cache = {}
        self.data = None
        self.data_fn = None
+        self.cacheclean = True

        if self.cachedir in [None, '']:
            self.has_cache = False
            bb.msg.note(1, bb.msg.domain.Cache, "Not using a cache. Set CACHE = <directory> to enable.")
-        else:
-            self.has_cache = True
-            self.cachefile = os.path.join(self.cachedir,"bb_cache.dat")
-            
-            bb.msg.debug(1, bb.msg.domain.Cache, "Using cache in '%s'" % self.cachedir)
-            try:
-                os.stat( self.cachedir )
-            except OSError:
-                bb.mkdirhier( self.cachedir )
+            return

-        if self.has_cache and (self.mtime(self.cachefile)):
+        self.has_cache = True
+        self.cachefile = os.path.join(self.cachedir, "bb_cache.dat")
+
+        bb.msg.debug(1, bb.msg.domain.Cache, "Using cache in '%s'" % self.cachedir)
+        bb.utils.mkdirhier(self.cachedir)
+
+        # If any of configuration.data's dependencies are newer than the
+        # cache there isn't even any point in loading it...
+        newest_mtime = 0
+        deps = bb.data.getVar("__depends", data)
+
+        old_mtimes = [old_mtime for f, old_mtime in deps]
+        old_mtimes.append(newest_mtime)
+        newest_mtime = max(old_mtimes)
+
+        if bb.parse.cached_mtime_noerror(self.cachefile) >= newest_mtime:
            try:
-                p = pickle.Unpickler( file(self.cachefile,"rb"))
+                p = pickle.Unpickler(file(self.cachefile, "rb"))
                self.depends_cache, version_data = p.load()
                if version_data['CACHE_VER'] != __cache_version__:
-                    raise ValueError, 'Cache Version Mismatch'
+                    raise ValueError('Cache Version Mismatch')
                if version_data['BITBAKE_VER'] != bb.__version__:
-                    raise ValueError, 'Bitbake Version Mismatch'
+                    raise ValueError('Bitbake Version Mismatch')
            except EOFError:
                bb.msg.note(1, bb.msg.domain.Cache, "Truncated cache found, rebuilding...")
                self.depends_cache = {}
-            except (ValueError, KeyError):
+            except:
                bb.msg.note(1, bb.msg.domain.Cache, "Invalid cache found, rebuilding...")
                self.depends_cache = {}
-
-        if self.depends_cache:
-            for fn in self.depends_cache.keys():
-                self.clean[fn] = ""
-                self.cacheValidUpdate(fn)
+        else:
+            if os.path.isfile(self.cachefile):
+                bb.msg.note(1, bb.msg.domain.Cache, "Out of date cache found, rebuilding...")

    def getVar(self, var, fn, exp = 0):
        """
        Gets the value of a variable
        (similar to getVar in the data class)
-        
+
        There are two scenarios:
          1. We have cached data - serve from depends_cache[fn]
-          2. We're learning what data to cache - serve from data 
+          2. We're learning what data to cache - serve from data
             backend but add a copy of the data to the cache.
        """
-
        if fn in self.clean:
            return self.depends_cache[fn][var]

-        if not fn in self.depends_cache:
-            self.depends_cache[fn] = {}
+        self.depends_cache.setdefault(fn, {})

        if fn != self.data_fn:
            # We're trying to access data in the cache which doesn't exist
            # yet setData hasn't been called to setup the right access. Very bad.
            bb.msg.error(bb.msg.domain.Cache, "Parsing error data_fn %s and fn %s don't match" % (self.data_fn, fn))

+        self.cacheclean = False
        result = bb.data.getVar(var, self.data, exp)
        self.depends_cache[fn][var] = result
        return result

-    def setData(self, fn, data):
+    def setData(self, virtualfn, fn, data):
        """
        Called to prime bb_cache ready to learn which variables to cache.
        Will be followed by calls to self.getVar which aren't cached
        but can be fulfilled from self.data.
        """
-        self.data_fn = fn
+        self.data_fn = virtualfn
        self.data = data

        # Make sure __depends makes the depends_cache
-        self.getVar("__depends", fn, True)
-        self.depends_cache[fn]["CACHETIMESTAMP"] = bb.parse.cached_mtime(fn)
+        # If we're a virtual class we need to make sure all our depends are appended
+        # to the depends of fn.
+        depends = self.getVar("__depends", virtualfn) or set()
+        self.depends_cache.setdefault(fn, {})
+        if "__depends" not in self.depends_cache[fn] or not self.depends_cache[fn]["__depends"]:
+            self.depends_cache[fn]["__depends"] = depends
+        else:
+            self.depends_cache[fn]["__depends"].update(depends)

-    def loadDataFull(self, fn, cfgData):
+        # Make sure the variants always make it into the cache too
+        self.getVar('__VARIANTS', virtualfn, True)
+
+        self.depends_cache[virtualfn]["CACHETIMESTAMP"] = bb.parse.cached_mtime(fn)
+
+    def virtualfn2realfn(self, virtualfn):
+        """
+        Convert a virtual file name to a real one + the associated subclass keyword
+        """
+
+        fn = virtualfn
+        cls = ""
+        if virtualfn.startswith('virtual:'):
+            cls = virtualfn.split(':', 2)[1]
+            fn = virtualfn.replace('virtual:' + cls + ':', '')
+        #bb.msg.debug(2, bb.msg.domain.Cache, "virtualfn2realfn %s to %s %s" % (virtualfn, fn, cls))
+        return (fn, cls)
+
+    def realfn2virtual(self, realfn, cls):
+        """
+        Convert a real filename + the associated subclass keyword to a virtual filename
+        """
+        if cls == "":
+            #bb.msg.debug(2, bb.msg.domain.Cache, "realfn2virtual %s and '%s' to %s" % (realfn, cls, realfn))
+            return realfn
+        #bb.msg.debug(2, bb.msg.domain.Cache, "realfn2virtual %s and %s to %s" % (realfn, cls, "virtual:" + cls + ":" + realfn))
+        return "virtual:" + cls + ":" + realfn
+
+    def loadDataFull(self, virtualfn, appends, cfgData):
        """
        Return a complete set of data for fn.
        To do this, we need to parse the file.
        """
-        bb_data, skipped = self.load_bbfile(fn, cfgData)
-        return bb_data

-    def loadData(self, fn, cfgData):
+        (fn, cls) = self.virtualfn2realfn(virtualfn)
+
+        bb.msg.debug(1, bb.msg.domain.Cache, "Parsing %s (full)" % fn)
+
+        bb_data = self.load_bbfile(fn, appends, cfgData)
+        return bb_data[cls]
+
+    def loadData(self, fn, appends, cfgData, cacheData):
        """
        Load a subset of data for fn.
        If the cached data is valid we do nothing,
@@ -142,14 +186,39 @@ class Cache:
        to record the variables accessed.
        Return the cache status and whether the file was skipped when parsed
        """
-        if self.cacheValid(fn):
-            if "SKIPPED" in self.depends_cache[fn]:
-                return True, True
-            return True, False
+        skipped = 0
+        virtuals = 0
+
+        if fn not in self.checked:
+            self.cacheValidUpdate(fn)
+
+        if self.cacheValid(fn):
+            multi = self.getVar('__VARIANTS', fn, True)
+            for cls in (multi or "").split() + [""]:
+                virtualfn = self.realfn2virtual(fn, cls)
+                if self.depends_cache[virtualfn]["__SKIPPED"]:
+                    skipped += 1
+                    bb.msg.debug(1, bb.msg.domain.Cache, "Skipping %s" % virtualfn)
+                    continue
+                self.handle_data(virtualfn, cacheData)
+                virtuals += 1
+            return True, skipped, virtuals
+
+        bb.msg.debug(1, bb.msg.domain.Cache, "Parsing %s" % fn)
+
+        bb_data = self.load_bbfile(fn, appends, cfgData)
+
+        for data in bb_data:
+            virtualfn = self.realfn2virtual(fn, data)
+            self.setData(virtualfn, fn, bb_data[data])
+            if self.getVar("__SKIPPED", virtualfn):
+                skipped += 1
+                bb.msg.debug(1, bb.msg.domain.Cache, "Skipping %s" % virtualfn)
+            else:
+                self.handle_data(virtualfn, cacheData)
+                virtuals += 1
+        return False, skipped, virtuals

-        bb_data, skipped = self.load_bbfile(fn, cfgData)
-        self.setData(fn, bb_data)
-        return False, skipped

    def cacheValid(self, fn):
        """
@@ -172,11 +241,10 @@ class Cache:
        if not self.has_cache:
            return False

-        # Check file still exists
-        if self.mtime(fn) == 0:
-            bb.msg.debug(2, bb.msg.domain.Cache, "Cache: %s not longer exists" % fn)
-            self.remove(fn)
-            return False
+        self.checked[fn] = ""
+
+        # Pretend we're clean so getVar works
+        self.clean[fn] = ""

        # File isn't in depends_cache
        if not fn in self.depends_cache:
@@ -184,39 +252,60 @@ class Cache:
            self.remove(fn)
            return False

+        mtime = bb.parse.cached_mtime_noerror(fn)
+
+        # Check file still exists
+        if mtime == 0:
+            bb.msg.debug(2, bb.msg.domain.Cache, "Cache: %s no longer exists" % fn)
+            self.remove(fn)
+            return False
+
        # Check the file's timestamp
-        if bb.parse.cached_mtime(fn) > self.getVar("CACHETIMESTAMP", fn, True):
+        if mtime != self.getVar("CACHETIMESTAMP", fn, True):
            bb.msg.debug(2, bb.msg.domain.Cache, "Cache: %s changed" % fn)
            self.remove(fn)
            return False

        # Check dependencies are still valid
        depends = self.getVar("__depends", fn, True)
-        for f,old_mtime in depends:
-            # Check if file still exists
-            if self.mtime(f) == 0:
-                return False
+        if depends:
+            for f, old_mtime in depends:
+                fmtime = bb.parse.cached_mtime_noerror(f)
+                # Check if file still exists
+                if old_mtime != 0 and fmtime == 0:
+                    self.remove(fn)
+                    return False

-            new_mtime = bb.parse.cached_mtime(f)
-            if (new_mtime > old_mtime):
-                bb.msg.debug(2, bb.msg.domain.Cache, "Cache: %s's dependency %s changed" % (fn, f))
-                self.remove(fn)
-                return False
+                if (fmtime != old_mtime):
+                    bb.msg.debug(2, bb.msg.domain.Cache, "Cache: %s's dependency %s changed" % (fn, f))
+                    self.remove(fn)
+                    return False

-        bb.msg.debug(2, bb.msg.domain.Cache, "Depends Cache: %s is clean" % fn)
+        #bb.msg.debug(2, bb.msg.domain.Cache, "Depends Cache: %s is clean" % fn)
        if not fn in self.clean:
            self.clean[fn] = ""

-        return True
+        invalid = False
+        # Mark extended class data as clean too
+        multi = self.getVar('__VARIANTS', fn, True)
+        for cls in (multi or "").split():
+            virtualfn = self.realfn2virtual(fn, cls)
+            self.clean[virtualfn] = ""
+            if not virtualfn in self.depends_cache:
+                bb.msg.debug(2, bb.msg.domain.Cache, "Cache: %s is not cached" % virtualfn)
+                invalid = True

-    def skip(self, fn):
-        """
-        Mark a fn as skipped
-        Called from the parser
-        """
-        if not fn in self.depends_cache:
-            self.depends_cache[fn] = {}
-        self.depends_cache[fn]["SKIPPED"] = "1"
+        # If any one of the varients is not present, mark cache as invalid for all
+        if invalid:
+            for cls in (multi or "").split():
+                virtualfn = self.realfn2virtual(fn, cls)
+                bb.msg.debug(2, bb.msg.domain.Cache, "Cache: Removing %s from cache" % virtualfn)
+                del self.clean[virtualfn]
+            bb.msg.debug(2, bb.msg.domain.Cache, "Cache: Removing %s from cache" % fn)
+            del self.clean[fn]
+            return False
+
+        return True

    def remove(self, fn):
        """
@@ -234,38 +323,52 @@ class Cache:
        Save the cache
        Called from the parser when complete (or exiting)
        """
+        import copy

        if not self.has_cache:
            return

+        if self.cacheclean:
+            bb.msg.note(1, bb.msg.domain.Cache, "Cache is clean, not saving.")
+            return
+
        version_data = {}
        version_data['CACHE_VER'] = __cache_version__
        version_data['BITBAKE_VER'] = bb.__version__

+        cache_data = copy.copy(self.depends_cache)
+        for fn in self.depends_cache:
+            if '__BB_DONT_CACHE' in self.depends_cache[fn] and self.depends_cache[fn]['__BB_DONT_CACHE']:
+                bb.msg.debug(2, bb.msg.domain.Cache, "Not caching %s, marked as not cacheable" % fn)
+                del cache_data[fn]
+            elif 'PV' in self.depends_cache[fn] and 'SRCREVINACTION' in self.depends_cache[fn]['PV']:
+                bb.msg.error(bb.msg.domain.Cache, "Not caching %s as it had SRCREVINACTION in PV. Please report this bug" % fn)
+                del cache_data[fn]
+
        p = pickle.Pickler(file(self.cachefile, "wb" ), -1 )
-        p.dump([self.depends_cache, version_data])
+        p.dump([cache_data, version_data])

    def mtime(self, cachefile):
        return bb.parse.cached_mtime_noerror(cachefile)

    def handle_data(self, file_name, cacheData):
        """
-        Save data we need into the cache 
+        Save data we need into the cache
        """

        pn       = self.getVar('PN', file_name, True)
        pe       = self.getVar('PE', file_name, True) or "0"
        pv       = self.getVar('PV', file_name, True)
+        if 'SRCREVINACTION' in pv:
+            bb.msg.note(1, bb.msg.domain.Cache, "Found SRCREVINACTION in PV (%s) or %s. Please report this bug." % (pv, file_name))
        pr       = self.getVar('PR', file_name, True)
        dp       = int(self.getVar('DEFAULT_PREFERENCE', file_name, True) or "0")
-        provides  = Set([pn] + (self.getVar("PROVIDES", file_name, True) or "").split())
        depends   = bb.utils.explode_deps(self.getVar("DEPENDS", file_name, True) or "")
        packages  = (self.getVar('PACKAGES', file_name, True) or "").split()
        packages_dynamic = (self.getVar('PACKAGES_DYNAMIC', file_name, True) or "").split()
        rprovides = (self.getVar("RPROVIDES", file_name, True) or "").split()

-        cacheData.task_queues[file_name] = self.getVar("_task_graph", file_name, True)
-        cacheData.task_deps[file_name] = self.getVar("_task_deps", file_name, True)
+        cacheData.task_deps[file_name] = self.getVar("_task_deps", file_name)

        # build PackageName to FileName lookup table
        if pn not in cacheData.pkg_pn:
@@ -274,35 +377,48 @@ class Cache:

        cacheData.stamp[file_name] = self.getVar('STAMP', file_name, True)

+        cacheData.tasks[file_name] = self.getVar('__BBTASKS', file_name, True)
+        for t in cacheData.tasks[file_name]:
+            cacheData.basetaskhash[file_name + "." + t] = self.getVar("BB_BASEHASH_task-%s" % t, file_name, True)
+
        # build FileName to PackageName lookup table
        cacheData.pkg_fn[file_name] = pn
-        cacheData.pkg_pepvpr[file_name] = (pe,pv,pr)
+        cacheData.pkg_pepvpr[file_name] = (pe, pv, pr)
        cacheData.pkg_dp[file_name] = dp

+        provides = [pn]
+        for provide in (self.getVar("PROVIDES", file_name, True) or "").split():
+            if provide not in provides:
+                provides.append(provide)
+
        # Build forward and reverse provider hashes
        # Forward: virtual -> [filenames]
        # Reverse: PN -> [virtuals]
        if pn not in cacheData.pn_provides:
-            cacheData.pn_provides[pn] = Set()
-        cacheData.pn_provides[pn] |= provides
+            cacheData.pn_provides[pn] = []

+        cacheData.fn_provides[file_name] = provides
        for provide in provides:
            if provide not in cacheData.providers:
                cacheData.providers[provide] = []
            cacheData.providers[provide].append(file_name)
+            if not provide in cacheData.pn_provides[pn]:
+                cacheData.pn_provides[pn].append(provide)

-        cacheData.deps[file_name] = Set()
+        cacheData.deps[file_name] = []
        for dep in depends:
-            cacheData.all_depends.add(dep)
-            cacheData.deps[file_name].add(dep)
+            if not dep in cacheData.deps[file_name]:
+                cacheData.deps[file_name].append(dep)
+            if not dep in cacheData.all_depends:
+                cacheData.all_depends.append(dep)

-        # Build reverse hash for PACKAGES, so runtime dependencies 
+        # Build reverse hash for PACKAGES, so runtime dependencies
        # can be be resolved (RDEPENDS, RRECOMMENDS etc.)
        for package in packages:
            if not package in cacheData.packages:
                cacheData.packages[package] = []
            cacheData.packages[package].append(file_name)
-            rprovides += (self.getVar("RPROVIDES_%s" % package, file_name, 1) or "").split() 
+            rprovides += (self.getVar("RPROVIDES_%s" % package, file_name, 1) or "").split()

        for package in packages_dynamic:
            if not package in cacheData.packages_dynamic:
@@ -316,68 +432,74 @@ class Cache:

        # Build hash of runtime depends and rececommends

-        def add_dep(deplist, deps):
-            for dep in deps:
-                if not dep in deplist:
-                    deplist[dep] = ""
-
        if not file_name in cacheData.rundeps:
            cacheData.rundeps[file_name] = {}
        if not file_name in cacheData.runrecs:
            cacheData.runrecs[file_name] = {}

+        rdepends = self.getVar('RDEPENDS', file_name, True) or ""
+        rrecommends = self.getVar('RRECOMMENDS', file_name, True) or ""
        for package in packages + [pn]:
            if not package in cacheData.rundeps[file_name]:
-                cacheData.rundeps[file_name][package] = {}
+                cacheData.rundeps[file_name][package] = []
            if not package in cacheData.runrecs[file_name]:
-                cacheData.runrecs[file_name][package] = {}
+                cacheData.runrecs[file_name][package] = []

-            add_dep(cacheData.rundeps[file_name][package], bb.utils.explode_deps(self.getVar('RDEPENDS', file_name, True) or ""))
-            add_dep(cacheData.runrecs[file_name][package], bb.utils.explode_deps(self.getVar('RRECOMMENDS', file_name, True) or ""))
-            add_dep(cacheData.rundeps[file_name][package], bb.utils.explode_deps(self.getVar("RDEPENDS_%s" % package, file_name, True) or ""))
-            add_dep(cacheData.runrecs[file_name][package], bb.utils.explode_deps(self.getVar("RRECOMMENDS_%s" % package, file_name, True) or ""))
+            cacheData.rundeps[file_name][package] = rdepends + " " + (self.getVar("RDEPENDS_%s" % package, file_name, True) or "")
+            cacheData.runrecs[file_name][package] = rrecommends + " " + (self.getVar("RRECOMMENDS_%s" % package, file_name, True) or "")

        # Collect files we may need for possible world-dep
        # calculations
        if not self.getVar('BROKEN', file_name, True) and not self.getVar('EXCLUDE_FROM_WORLD', file_name, True):
            cacheData.possible_world.append(file_name)

+        cacheData.hashfn[file_name] = self.getVar('BB_HASHFILENAME', file_name, True)

-    def load_bbfile( self, bbfile , config):
+        # Touch this to make sure its in the cache
+        self.getVar('__BB_DONT_CACHE', file_name, True)
+        self.getVar('__VARIANTS', file_name, True)
+
+    def load_bbfile(self, bbfile, appends, config):
        """
        Load and parse one .bb build file
        Return the data and whether parsing resulted in the file being skipped
        """
+        chdir_back = False

-        import bb
-        from bb import utils, data, parse, debug, event, fatal
+        from bb import data, parse

        # expand tmpdir to include this topdir
        data.setVar('TMPDIR', data.getVar('TMPDIR', config, 1) or "", config)
        bbfile_loc = os.path.abspath(os.path.dirname(bbfile))
        oldpath = os.path.abspath(os.getcwd())
-        if self.mtime(bbfile_loc):
-            os.chdir(bbfile_loc)
+        parse.cached_mtime_noerror(bbfile_loc)
        bb_data = data.init_db(config)
+        # The ConfHandler first looks if there is a TOPDIR and if not
+        # then it would call getcwd().
+        # Previously, we chdir()ed to bbfile_loc, called the handler
+        # and finally chdir()ed back, a couple of thousand times. We now
+        # just fill in TOPDIR to point to bbfile_loc if there is no TOPDIR yet.
+        if not data.getVar('TOPDIR', bb_data):
+            chdir_back = True
+            data.setVar('TOPDIR', bbfile_loc, bb_data)
        try:
+            if appends:
+                data.setVar('__BBAPPEND', " ".join(appends), bb_data)
            bb_data = parse.handle(bbfile, bb_data) # read .bb data
-            os.chdir(oldpath)
-            return bb_data, False
-        except bb.parse.SkipPackage:
-            os.chdir(oldpath)
-            return bb_data, True
+            if chdir_back: os.chdir(oldpath)
+            return bb_data
        except:
-            os.chdir(oldpath)
+            if chdir_back: os.chdir(oldpath)
            raise

 def init(cooker):
    """
-    The Objective: Cache the minimum amount of data possible yet get to the 
+    The Objective: Cache the minimum amount of data possible yet get to the
    stage of building packages (i.e. tryBuild) without reparsing any .bb files.

-    To do this, we intercept getVar calls and only cache the variables we see 
-    being accessed. We rely on the cache getVar calls being made for all 
-    variables bitbake might need to use to reach this stage. For each cached 
+    To do this, we intercept getVar calls and only cache the variables we see
+    being accessed. We rely on the cache getVar calls being made for all
+    variables bitbake might need to use to reach this stage. For each cached
    file we need to track:

    * Its mtime
@@ -387,7 +509,7 @@ def init(cooker):
    Files causing parsing errors are evicted from the cache.

    """
-    return Cache(cooker)
+    return Cache(cooker.configuration.data)



@@ -414,7 +536,8 @@ class CacheData:
        self.pkg_pepvpr = {}
        self.pkg_dp = {}
        self.pn_provides = {}
-        self.all_depends = Set()
+        self.fn_provides = {}
+        self.all_depends = []
        self.deps = {}
        self.rundeps = {}
        self.runrecs = {}
@@ -422,12 +545,15 @@ class CacheData:
        self.task_deps = {}
        self.stamp = {}
        self.preferred = {}
+        self.tasks = {}
+        self.basetaskhash = {}
+        self.hashfn = {}

        """
        Indirect Cache variables
        (set elsewhere)
        """
        self.ignored_dependencies = []
-        self.world_target = Set()
+        self.world_target = set()
        self.bbfile_priority = {}
        self.bbfile_config_priorities = []
--- a/bitbake/lib/bb/codeparser.py
+++ b/bitbake/lib/bb/codeparser.py
@@ -0,0 +1,329 @@
+from pysh import pyshyacc, pyshlex
+from itertools import chain
+from bb import msg, utils
+import ast
+import codegen
+
+PARSERCACHE_VERSION = 2
+
+try:
+    import cPickle as pickle
+except ImportError:
+    import pickle
+    bb.msg.note(1, bb.msg.domain.Cache, "Importing cPickle failed. Falling back to a very slow implementation.")
+
+def check_indent(codestr):
+    """If the code is indented, add a top level piece of code to 'remove' the indentation"""
+
+    i = 0
+    while codestr[i] in ["\n", "	", " "]:
+        i = i + 1
+
+    if i == 0:
+        return codestr
+
+    if codestr[i-1] is "	" or codestr[i-1] is " ":
+        return "if 1:\n" + codestr        
+
+    return codestr
+
+pythonparsecache = {}
+shellparsecache = {}
+
+def parser_cachefile(d):
+    cachedir = bb.data.getVar("PERSISTENT_DIR", d, True) or bb.data.getVar("CACHE", d, True)
+    if cachedir in [None, '']:
+        return None
+    bb.utils.mkdirhier(cachedir)
+    cachefile = os.path.join(cachedir, "bb_codeparser.dat")
+    bb.msg.debug(1, bb.msg.domain.Cache, "Using cache in '%s' for codeparser cache" % cachefile)
+    return cachefile
+
+def parser_cache_init(d):
+
+    cachefile = parser_cachefile(d)
+    if not cachefile:
+        return
+
+    try:
+        p = pickle.Unpickler(file(cachefile, "rb"))
+        data, version = p.load()
+    except:
+        return
+
+    if version != PARSERCACHE_VERSION:
+        return
+
+    bb.codeparser.pythonparsecache = data[0]
+    bb.codeparser.shellparsecache = data[1]
+
+def parser_cache_save(d):
+
+    cachefile = parser_cachefile(d)
+    if not cachefile:
+        return
+
+    p = pickle.Pickler(file(cachefile, "wb"), -1)
+    p.dump([[bb.codeparser.pythonparsecache, bb.codeparser.shellparsecache], PARSERCACHE_VERSION])
+
+class PythonParser():
+    class ValueVisitor():
+        """Visitor to traverse a python abstract syntax tree and obtain
+        the variables referenced via bitbake metadata APIs, and the external
+        functions called.
+        """
+
+        getvars = ("d.getVar", "bb.data.getVar", "data.getVar")
+        expands = ("d.expand", "bb.data.expand", "data.expand")
+        execs = ("bb.build.exec_func", "bb.build.exec_task")
+
+        @classmethod
+        def _compare_name(cls, strparts, node):
+            """Given a sequence of strings representing a python name,
+            where the last component is the actual Name and the prior
+            elements are Attribute nodes, determine if the supplied node
+            matches.
+            """
+
+            if not strparts:
+                return True
+
+            current, rest = strparts[0], strparts[1:]
+            if isinstance(node, ast.Attribute):
+                if current == node.attr:
+                    return cls._compare_name(rest, node.value)
+            elif isinstance(node, ast.Name):
+                if current == node.id:
+                    return True
+            return False
+
+        @classmethod
+        def compare_name(cls, value, node):
+            """Convenience function for the _compare_node method, which
+            can accept a string (which is split by '.' for you), or an
+            iterable of strings, in which case it checks to see if any of
+            them match, similar to isinstance.
+            """
+
+            if isinstance(value, basestring):
+                return cls._compare_name(tuple(reversed(value.split("."))),
+                                         node)
+            else:
+                return any(cls.compare_name(item, node) for item in value)
+
+        def __init__(self, value):
+            self.var_references = set()
+            self.var_execs = set()
+            self.direct_func_calls = set()
+            self.var_expands = set()
+            self.value = value
+
+        @classmethod
+        def warn(cls, func, arg):
+            """Warn about calls of bitbake APIs which pass a non-literal
+            argument for the variable name, as we're not able to track such
+            a reference.
+            """
+
+            try:
+                funcstr = codegen.to_source(func)
+                argstr = codegen.to_source(arg)
+            except TypeError:
+                msg.debug(2, None, "Failed to convert function and argument to source form")
+            else:
+                msg.debug(1, None, "Warning: in call to '%s', argument '%s' is not a literal" %
+                                     (funcstr, argstr))
+
+        def visit_Call(self, node):
+            if self.compare_name(self.getvars, node.func):
+                if isinstance(node.args[0], ast.Str):
+                    self.var_references.add(node.args[0].s)
+                else:
+                    self.warn(node.func, node.args[0])
+            elif self.compare_name(self.expands, node.func):
+                if isinstance(node.args[0], ast.Str):
+                    self.warn(node.func, node.args[0])
+                    self.var_expands.update(node.args[0].s)
+                elif isinstance(node.args[0], ast.Call) and \
+                     self.compare_name(self.getvars, node.args[0].func):
+                    pass
+                else:
+                    self.warn(node.func, node.args[0])
+            elif self.compare_name(self.execs, node.func):
+                if isinstance(node.args[0], ast.Str):
+                    self.var_execs.add(node.args[0].s)
+                else:
+                    self.warn(node.func, node.args[0])
+            elif isinstance(node.func, ast.Name):
+                self.direct_func_calls.add(node.func.id)
+            elif isinstance(node.func, ast.Attribute):
+                # We must have a qualified name.  Therefore we need
+                # to walk the chain of 'Attribute' nodes to determine
+                # the qualification.
+                attr_node = node.func.value
+                identifier = node.func.attr
+                while isinstance(attr_node, ast.Attribute):
+                    identifier = attr_node.attr + "." + identifier
+                    attr_node = attr_node.value
+                if isinstance(attr_node, ast.Name):
+                    identifier = attr_node.id + "." + identifier
+                self.direct_func_calls.add(identifier)
+
+    def __init__(self):
+        #self.funcdefs = set()
+        self.execs = set()
+        #self.external_cmds = set()
+        self.references = set()
+
+    def parse_python(self, node):
+
+        h = hash(str(node))
+
+        if h in pythonparsecache:
+            self.references = pythonparsecache[h]["refs"]
+            self.execs = pythonparsecache[h]["execs"]
+            return
+
+        code = compile(check_indent(str(node)), "<string>", "exec", 
+                       ast.PyCF_ONLY_AST)
+
+        visitor = self.ValueVisitor(code)
+        for n in ast.walk(code):
+            if n.__class__.__name__ == "Call":
+                visitor.visit_Call(n)
+
+        self.references.update(visitor.var_references)
+        self.references.update(visitor.var_execs)
+        self.execs = visitor.direct_func_calls
+
+        pythonparsecache[h] = {}
+        pythonparsecache[h]["refs"] = self.references
+        pythonparsecache[h]["execs"] = self.execs
+
+class ShellParser():
+    def __init__(self):
+        self.funcdefs = set()
+        self.allexecs = set()
+        self.execs = set()
+
+    def parse_shell(self, value):
+        """Parse the supplied shell code in a string, returning the external
+        commands it executes.
+        """
+
+        h = hash(str(value))
+
+        if h in shellparsecache:
+            self.execs = shellparsecache[h]["execs"]
+            return self.execs
+
+        try:
+            tokens, _ = pyshyacc.parse(value, eof=True, debug=False)
+        except pyshlex.NeedMore:
+            raise ShellSyntaxError("Unexpected EOF")
+
+        for token in tokens:
+            self.process_tokens(token)
+        self.execs = set(cmd for cmd in self.allexecs if cmd not in self.funcdefs)
+
+        shellparsecache[h] = {}
+        shellparsecache[h]["execs"] = self.execs
+
+        return self.execs
+
+    def process_tokens(self, tokens):
+        """Process a supplied portion of the syntax tree as returned by
+        pyshyacc.parse.
+        """
+
+        def function_definition(value):
+            self.funcdefs.add(value.name)
+            return [value.body], None
+
+        def case_clause(value):
+            # Element 0 of each item in the case is the list of patterns, and
+            # Element 1 of each item in the case is the list of commands to be
+            # executed when that pattern matches.
+            words = chain(*[item[0] for item in value.items])
+            cmds  = chain(*[item[1] for item in value.items])
+            return cmds, words
+
+        def if_clause(value):
+            main = chain(value.cond, value.if_cmds)
+            rest = value.else_cmds
+            if isinstance(rest, tuple) and rest[0] == "elif":
+                return chain(main, if_clause(rest[1]))
+            else:
+                return chain(main, rest)
+
+        def simple_command(value):
+            return None, chain(value.words, (assign[1] for assign in value.assigns))
+
+        token_handlers = {
+            "and_or": lambda x: ((x.left, x.right), None),
+            "async": lambda x: ([x], None),
+            "brace_group": lambda x: (x.cmds, None),
+            "for_clause": lambda x: (x.cmds, x.items),
+            "function_definition": function_definition,
+            "if_clause": lambda x: (if_clause(x), None),
+            "pipeline": lambda x: (x.commands, None),
+            "redirect_list": lambda x: ([x.cmd], None),
+            "subshell": lambda x: (x.cmds, None),
+            "while_clause": lambda x: (chain(x.condition, x.cmds), None),
+            "until_clause": lambda x: (chain(x.condition, x.cmds), None),
+            "simple_command": simple_command,
+            "case_clause": case_clause,
+        }
+
+        for token in tokens:
+            name, value = token
+            try:
+                more_tokens, words = token_handlers[name](value)
+            except KeyError:
+                raise NotImplementedError("Unsupported token type " + name)
+
+            if more_tokens:
+                self.process_tokens(more_tokens)
+
+            if words:
+                self.process_words(words)
+
+    def process_words(self, words):
+        """Process a set of 'words' in pyshyacc parlance, which includes
+        extraction of executed commands from $() blocks, as well as grabbing
+        the command name argument.
+        """
+
+        words = list(words)
+        for word in list(words):
+            wtree = pyshlex.make_wordtree(word[1])
+            for part in wtree:
+                if not isinstance(part, list):
+                    continue
+
+                if part[0] in ('`', '$('):
+                    command = pyshlex.wordtree_as_string(part[1:-1])
+                    self.parse_shell(command)
+
+                    if word[0] in ("cmd_name", "cmd_word"):
+                        if word in words:
+                            words.remove(word)
+
+        usetoken = False
+        for word in words:
+            if word[0] in ("cmd_name", "cmd_word") or \
+               (usetoken and word[0] == "TOKEN"):
+                if "=" in word[1]:
+                    usetoken = True
+                    continue
+
+                cmd = word[1]
+                if cmd.startswith("$"):
+                    msg.debug(1, None, "Warning: execution of non-literal command '%s'" % cmd)
+                elif cmd == "eval":
+                    command = " ".join(word for _, word in words[1:])
+                    self.parse_shell(command)
+                else:
+                    self.allexecs.add(cmd)
+                break
+
--- a/bitbake/lib/bb/command.py
+++ b/bitbake/lib/bb/command.py
@@ -0,0 +1,280 @@
+"""
+BitBake 'Command' module
+
+Provide an interface to interact with the bitbake server through 'commands'
+"""
+
+# Copyright (C) 2006-2007  Richard Purdie
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License version 2 as
+# published by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License along
+# with this program; if not, write to the Free Software Foundation, Inc.,
+# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+
+"""
+The bitbake server takes 'commands' from its UI/commandline.
+Commands are either synchronous or asynchronous.
+Async commands return data to the client in the form of events.
+Sync commands must only return data through the function return value
+and must not trigger events, directly or indirectly.
+Commands are queued in a CommandQueue
+"""
+
+import bb.event
+import bb.cooker
+import bb.data
+
+async_cmds = {}
+sync_cmds = {}
+
+class Command:
+    """
+    A queue of asynchronous commands for bitbake
+    """
+    def __init__(self, cooker):
+
+        self.cooker = cooker
+        self.cmds_sync = CommandsSync()
+        self.cmds_async = CommandsAsync()
+
+        # FIXME Add lock for this
+        self.currentAsyncCommand = None
+
+        for attr in CommandsSync.__dict__:
+            command = attr[:].lower()
+            method = getattr(CommandsSync, attr)
+            sync_cmds[command] = (method)
+
+        for attr in CommandsAsync.__dict__:
+            command = attr[:].lower()
+            method = getattr(CommandsAsync, attr)
+            async_cmds[command] = (method)
+
+    def runCommand(self, commandline):
+        try:
+            command = commandline.pop(0)
+            if command in CommandsSync.__dict__:
+                # Can run synchronous commands straight away
+                return getattr(CommandsSync, command)(self.cmds_sync, self, commandline)
+            if self.currentAsyncCommand is not None:
+                return "Busy (%s in progress)" % self.currentAsyncCommand[0]
+            if command not in CommandsAsync.__dict__:
+                return "No such command"
+            self.currentAsyncCommand = (command, commandline)
+            self.cooker.server.register_idle_function(self.cooker.runCommands, self.cooker)
+            return True
+        except:
+            import traceback
+            return traceback.format_exc()
+
+    def runAsyncCommand(self):
+        try:
+            if self.currentAsyncCommand is not None:
+                (command, options) = self.currentAsyncCommand
+                commandmethod = getattr(CommandsAsync, command)
+                needcache = getattr( commandmethod, "needcache" )
+                if needcache and self.cooker.cookerState != bb.cooker.cookerParsed:
+                    self.cooker.updateCache()
+                    return True
+                else:
+                    commandmethod(self.cmds_async, self, options)
+                    return False
+            else:
+                return False
+        except KeyboardInterrupt as exc:
+            self.finishAsyncCommand("Interrupted")
+            return False
+        except SystemExit as exc:
+            arg = exc.args[0]
+            if isinstance(arg, basestring):
+                self.finishAsyncCommand(arg)
+            else:
+                self.finishAsyncCommand("Exited with %s" % arg)
+            return False
+        except Exception:
+            import traceback
+            self.finishAsyncCommand(traceback.format_exc())
+            return False
+
+    def finishAsyncCommand(self, error = None):
+        if error:
+            bb.event.fire(CookerCommandFailed(error), self.cooker.configuration.event_data)
+        else:
+            bb.event.fire(CookerCommandCompleted(), self.cooker.configuration.event_data)
+        self.currentAsyncCommand = None
+
+
+class CommandsSync:
+    """
+    A class of synchronous commands
+    These should run quickly so as not to hurt interactive performance.
+    These must not influence any running synchronous command.
+    """
+
+    def stateShutdown(self, command, params):
+        """
+        Trigger cooker 'shutdown' mode
+        """
+        command.cooker.cookerAction = bb.cooker.cookerShutdown
+
+    def stateStop(self, command, params):
+        """
+        Stop the cooker
+        """
+        command.cooker.cookerAction = bb.cooker.cookerStop
+
+    def getCmdLineAction(self, command, params):
+        """
+        Get any command parsed from the commandline
+        """
+        return command.cooker.commandlineAction
+
+    def getVariable(self, command, params):
+        """
+        Read the value of a variable from configuration.data
+        """
+        varname = params[0]
+        expand = True
+        if len(params) > 1:
+            expand = params[1]
+
+        return bb.data.getVar(varname, command.cooker.configuration.data, expand)
+
+    def setVariable(self, command, params):
+        """
+        Set the value of variable in configuration.data
+        """
+        varname = params[0]
+        value = params[1]
+        bb.data.setVar(varname, value, command.cooker.configuration.data)
+
+
+class CommandsAsync:
+    """
+    A class of asynchronous commands
+    These functions communicate via generated events.
+    Any function that requires metadata parsing should be here.
+    """
+
+    def buildFile(self, command, params):
+        """
+        Build a single specified .bb file
+        """
+        bfile = params[0]
+        task = params[1]
+
+        command.cooker.buildFile(bfile, task)
+    buildFile.needcache = False
+
+    def buildTargets(self, command, params):
+        """
+        Build a set of targets
+        """
+        pkgs_to_build = params[0]
+        task = params[1]
+
+        command.cooker.buildTargets(pkgs_to_build, task)
+    buildTargets.needcache = True
+
+    def generateDepTreeEvent(self, command, params):
+        """
+        Generate an event containing the dependency information
+        """
+        pkgs_to_build = params[0]
+        task = params[1]
+
+        command.cooker.generateDepTreeEvent(pkgs_to_build, task)
+        command.finishAsyncCommand()
+    generateDepTreeEvent.needcache = True
+
+    def generateDotGraph(self, command, params):
+        """
+        Dump dependency information to disk as .dot files
+        """
+        pkgs_to_build = params[0]
+        task = params[1]
+
+        command.cooker.generateDotGraphFiles(pkgs_to_build, task)
+        command.finishAsyncCommand()
+    generateDotGraph.needcache = True
+
+    def showVersions(self, command, params):
+        """
+        Show the currently selected versions
+        """
+        command.cooker.showVersions()
+        command.finishAsyncCommand()
+    showVersions.needcache = True
+
+    def showEnvironmentTarget(self, command, params):
+        """
+        Print the environment of a target recipe
+        (needs the cache to work out which recipe to use)
+        """
+        pkg = params[0]
+
+        command.cooker.showEnvironment(None, pkg)
+        command.finishAsyncCommand()
+    showEnvironmentTarget.needcache = True
+
+    def showEnvironment(self, command, params):
+        """
+        Print the standard environment
+        or if specified the environment for a specified recipe
+        """
+        bfile = params[0]
+
+        command.cooker.showEnvironment(bfile)
+        command.finishAsyncCommand()
+    showEnvironment.needcache = False
+
+    def parseFiles(self, command, params):
+        """
+        Parse the .bb files
+        """
+        command.cooker.updateCache()
+        command.finishAsyncCommand()
+    parseFiles.needcache = True
+
+    def compareRevisions(self, command, params):
+        """
+        Parse the .bb files
+        """
+        command.cooker.compareRevisions()
+        command.finishAsyncCommand()
+    compareRevisions.needcache = True
+
+#
+# Events
+#
+class CookerCommandCompleted(bb.event.Event):
+    """
+    Cooker command completed
+    """
+    def  __init__(self):
+        bb.event.Event.__init__(self)
+
+
+class CookerCommandFailed(bb.event.Event):
+    """
+    Cooker command completed
+    """
+    def  __init__(self, error):
+        bb.event.Event.__init__(self)
+        self.error = error
+
+class CookerCommandSetExitCode(bb.event.Event):
+    """
+    Set the exit code for a cooker command
+    """
+    def  __init__(self, exitcode):
+        bb.event.Event.__init__(self)
+        self.exitcode = int(exitcode)
--- a/bitbake/lib/bb/cooker.py
+++ b/bitbake/lib/bb/cooker.py
--- a/bitbake/lib/bb/daemonize.py
+++ b/bitbake/lib/bb/daemonize.py
@@ -0,0 +1,190 @@
+"""
+Python Deamonizing helper
+
+Configurable daemon behaviors:
+
+    1.) The current working directory set to the "/" directory.
+    2.) The current file creation mode mask set to 0.
+    3.) Close all open files (1024). 
+    4.) Redirect standard I/O streams to "/dev/null".
+
+A failed call to fork() now raises an exception.
+
+References:
+    1) Advanced Programming in the Unix Environment: W. Richard Stevens
+    2) Unix Programming Frequently Asked Questions:
+            http://www.erlenstar.demon.co.uk/unix/faq_toc.html
+
+Modified to allow a function to be daemonized and return for 
+bitbake use by Richard Purdie
+"""
+
+__author__ = "Chad J. Schroeder"
+__copyright__ = "Copyright (C) 2005 Chad J. Schroeder"
+__version__ = "0.2"
+
+# Standard Python modules.
+import os                    # Miscellaneous OS interfaces.
+import sys                  # System-specific parameters and functions.
+
+# Default daemon parameters.
+# File mode creation mask of the daemon.
+# For BitBake's children, we do want to inherit the parent umask.
+UMASK = None
+
+# Default maximum for the number of available file descriptors.
+MAXFD = 1024
+
+# The standard I/O file descriptors are redirected to /dev/null by default.
+if (hasattr(os, "devnull")):
+    REDIRECT_TO = os.devnull
+else:
+    REDIRECT_TO = "/dev/null"
+
+def createDaemon(function, logfile):
+    """
+    Detach a process from the controlling terminal and run it in the
+    background as a daemon, returning control to the caller.
+    """
+
+    try:
+        # Fork a child process so the parent can exit.  This returns control to
+        # the command-line or shell.  It also guarantees that the child will not
+        # be a process group leader, since the child receives a new process ID
+        # and inherits the parent's process group ID.  This step is required
+        # to insure that the next call to os.setsid is successful.
+        pid = os.fork()
+    except OSError as e:
+        raise Exception("%s [%d]" % (e.strerror, e.errno))
+
+    if (pid == 0):      # The first child.
+        # To become the session leader of this new session and the process group
+        # leader of the new process group, we call os.setsid().  The process is
+        # also guaranteed not to have a controlling terminal.
+        os.setsid()
+
+        # Is ignoring SIGHUP necessary?
+        #
+        # It's often suggested that the SIGHUP signal should be ignored before
+        # the second fork to avoid premature termination of the process.  The
+        # reason is that when the first child terminates, all processes, e.g.
+        # the second child, in the orphaned group will be sent a SIGHUP.
+        #
+        # "However, as part of the session management system, there are exactly
+        # two cases where SIGHUP is sent on the death of a process:
+        #
+        #    1) When the process that dies is the session leader of a session that
+        #        is attached to a terminal device, SIGHUP is sent to all processes
+        #        in the foreground process group of that terminal device.
+        #    2) When the death of a process causes a process group to become
+        #        orphaned, and one or more processes in the orphaned group are
+        #        stopped, then SIGHUP and SIGCONT are sent to all members of the
+        #        orphaned group." [2]
+        #
+        # The first case can be ignored since the child is guaranteed not to have
+        # a controlling terminal.  The second case isn't so easy to dismiss.
+        # The process group is orphaned when the first child terminates and
+        # POSIX.1 requires that every STOPPED process in an orphaned process
+        # group be sent a SIGHUP signal followed by a SIGCONT signal.  Since the
+        # second child is not STOPPED though, we can safely forego ignoring the
+        # SIGHUP signal.  In any case, there are no ill-effects if it is ignored.
+        #
+        # import signal              # Set handlers for asynchronous events.
+        # signal.signal(signal.SIGHUP, signal.SIG_IGN)
+
+        try:
+            # Fork a second child and exit immediately to prevent zombies.  This
+            # causes the second child process to be orphaned, making the init
+            # process responsible for its cleanup.  And, since the first child is
+            # a session leader without a controlling terminal, it's possible for
+            # it to acquire one by opening a terminal in the future (System V-
+            # based systems).  This second fork guarantees that the child is no
+            # longer a session leader, preventing the daemon from ever acquiring
+            # a controlling terminal.
+            pid = os.fork()     # Fork a second child.
+        except OSError as e:
+            raise Exception("%s [%d]" % (e.strerror, e.errno))
+
+        if (pid == 0):  # The second child.
+            # We probably don't want the file mode creation mask inherited from
+            # the parent, so we give the child complete control over permissions.
+            if UMASK is not None:
+                os.umask(UMASK)
+        else:
+            # Parent (the first child) of the second child.
+            os._exit(0)
+    else:
+        # exit() or _exit()?
+        # _exit is like exit(), but it doesn't call any functions registered
+        # with atexit (and on_exit) or any registered signal handlers.  It also
+        # closes any open file descriptors.  Using exit() may cause all stdio
+        # streams to be flushed twice and any temporary files may be unexpectedly
+        # removed.  It's therefore recommended that child branches of a fork()
+        # and the parent branch(es) of a daemon use _exit().
+        return
+
+    # Close all open file descriptors.  This prevents the child from keeping
+    # open any file descriptors inherited from the parent.  There is a variety
+    # of methods to accomplish this task.  Three are listed below.
+    #
+    # Try the system configuration variable, SC_OPEN_MAX, to obtain the maximum
+    # number of open file descriptors to close.  If it doesn't exists, use
+    # the default value (configurable).
+    #
+    # try:
+    #     maxfd = os.sysconf("SC_OPEN_MAX")
+    # except (AttributeError, ValueError):
+    #     maxfd = MAXFD
+    #
+    # OR
+    #
+    # if (os.sysconf_names.has_key("SC_OPEN_MAX")):
+    #     maxfd = os.sysconf("SC_OPEN_MAX")
+    # else:
+    #     maxfd = MAXFD
+    #
+    # OR
+    #
+    # Use the getrlimit method to retrieve the maximum file descriptor number
+    # that can be opened by this process.  If there is not limit on the
+    # resource, use the default value.
+    #
+    import resource             # Resource usage information.
+    maxfd = resource.getrlimit(resource.RLIMIT_NOFILE)[1]
+    if (maxfd == resource.RLIM_INFINITY):
+        maxfd = MAXFD
+  
+    # Iterate through and close all file descriptors.
+#    for fd in range(0, maxfd):
+#        try:
+#            os.close(fd)
+#        except OSError:        # ERROR, fd wasn't open to begin with (ignored)
+#            pass
+
+    # Redirect the standard I/O file descriptors to the specified file.  Since
+    # the daemon has no controlling terminal, most daemons redirect stdin,
+    # stdout, and stderr to /dev/null.  This is done to prevent side-effects
+    # from reads and writes to the standard I/O file descriptors.
+
+    # This call to open is guaranteed to return the lowest file descriptor,
+    # which will be 0 (stdin), since it was closed above.
+#    os.open(REDIRECT_TO, os.O_RDWR)    # standard input (0)
+
+    # Duplicate standard input to standard output and standard error.
+#    os.dup2(0, 1)                      # standard output (1)
+#    os.dup2(0, 2)                      # standard error (2)
+
+
+    si = file('/dev/null', 'r')
+    so = file(logfile, 'w')
+    se = so
+
+
+    # Replace those fds with our own
+    os.dup2(si.fileno(), sys.stdin.fileno())
+    os.dup2(so.fileno(), sys.stdout.fileno())
+    os.dup2(se.fileno(), sys.stderr.fileno())
+
+    function()
+
+    os._exit(0)
--- a/bitbake/lib/bb/data.py
+++ b/bitbake/lib/bb/data.py
@@ -11,7 +11,7 @@ operations. At night the cookie monster came by and
 suggested 'give me cookies on setting the variables and
 things will work out'. Taking this suggestion into account
 applying the skills from the not yet passed 'Entwurf und
-Analyse von Algorithmen' lecture and the cookie 
+Analyse von Algorithmen' lecture and the cookie
 monster seems to be right. We will track setVar more carefully
 to have faster update_data and expandKeys operations.

@@ -37,36 +37,41 @@ the speed is more critical here.
 #
 #Based on functions from the base bb module, Copyright 2003 Holger Schurig

-import sys, os, re, time, types
+import sys, os, re
 if sys.argv[0][-5:] == "pydoc":
    path = os.path.dirname(os.path.dirname(sys.argv[1]))
 else:
    path = os.path.dirname(os.path.dirname(sys.argv[0]))
-sys.path.insert(0,path)
+sys.path.insert(0, path)
+from itertools import groupby

 from bb import data_smart
+from bb import codeparser
 import bb

 _dict_type = data_smart.DataSmart

 def init():
+    """Return a new object representing the Bitbake data"""
    return _dict_type()

 def init_db(parent = None):
+    """Return a new object representing the Bitbake data,
+    optionally based on an existing object"""
    if parent:
        return parent.createCopy()
    else:
        return _dict_type()

 def createCopy(source):
-     """Link the source set to the destination
-     If one does not find the value in the destination set,
-     search will go on to the source set to get the value.
-     Value from source are copy-on-write. i.e. any try to
-     modify one of them will end up putting the modified value
-     in the destination set.
-     """
-     return source.createCopy()
+    """Link the source set to the destination
+    If one does not find the value in the destination set,
+    search will go on to the source set to get the value.
+    Value from source are copy-on-write. i.e. any try to
+    modify one of them will end up putting the modified value
+    in the destination set.
+    """
+    return source.createCopy()

 def initVar(var, d):
    """Non-destructive var init for data structure"""
@@ -74,78 +79,34 @@ def initVar(var, d):


 def setVar(var, value, d):
-    """Set a variable to a given value
-
-    Example:
-        >>> d = init()
-        >>> setVar('TEST', 'testcontents', d)
-        >>> print getVar('TEST', d)
-        testcontents
-    """
-    d.setVar(var,value)
+    """Set a variable to a given value"""
+    d.setVar(var, value)


 def getVar(var, d, exp = 0):
-    """Gets the value of a variable
+    """Gets the value of a variable"""
+    return d.getVar(var, exp)

-    Example:
-        >>> d = init()
-        >>> setVar('TEST', 'testcontents', d)
-        >>> print getVar('TEST', d)
-        testcontents
-    """
-    return d.getVar(var,exp)
+
+def renameVar(key, newkey, d):
+    """Renames a variable from key to newkey"""
+    d.renameVar(key, newkey)

 def delVar(var, d):
-    """Removes a variable from the data set
-
-    Example:
-        >>> d = init()
-        >>> setVar('TEST', 'testcontents', d)
-        >>> print getVar('TEST', d)
-        testcontents
-        >>> delVar('TEST', d)
-        >>> print getVar('TEST', d)
-        None
-    """
+    """Removes a variable from the data set"""
    d.delVar(var)

 def setVarFlag(var, flag, flagvalue, d):
-    """Set a flag for a given variable to a given value
-
-    Example:
-        >>> d = init()
-        >>> setVarFlag('TEST', 'python', 1, d)
-        >>> print getVarFlag('TEST', 'python', d)
-        1
-    """
-    d.setVarFlag(var,flag,flagvalue)
+    """Set a flag for a given variable to a given value"""
+    d.setVarFlag(var, flag, flagvalue)

 def getVarFlag(var, flag, d):
-    """Gets given flag from given var
-
-    Example:
-        >>> d = init()
-        >>> setVarFlag('TEST', 'python', 1, d)
-        >>> print getVarFlag('TEST', 'python', d)
-        1
-    """
-    return d.getVarFlag(var,flag)
+    """Gets given flag from given var"""
+    return d.getVarFlag(var, flag)

 def delVarFlag(var, flag, d):
-    """Removes a given flag from the variable's flags
-
-    Example:
-        >>> d = init()
-        >>> setVarFlag('TEST', 'testflag', 1, d)
-        >>> print getVarFlag('TEST', 'testflag', d)
-        1
-        >>> delVarFlag('TEST', 'testflag', d)
-        >>> print getVarFlag('TEST', 'testflag', d)
-        None
-
-    """
-    d.delVarFlag(var,flag)
+    """Removes a given flag from the variable's flags"""
+    d.delVarFlag(var, flag)

 def setVarFlags(var, flags, d):
    """Set the flags for a given variable
@@ -154,121 +115,34 @@ def setVarFlags(var, flags, d):
        setVarFlags will not clear previous
        flags. Think of this method as
        addVarFlags
-
-    Example:
-        >>> d = init()
-        >>> myflags = {}
-        >>> myflags['test'] = 'blah'
-        >>> setVarFlags('TEST', myflags, d)
-        >>> print getVarFlag('TEST', 'test', d)
-        blah
    """
-    d.setVarFlags(var,flags)
+    d.setVarFlags(var, flags)

 def getVarFlags(var, d):
-    """Gets a variable's flags
-
-    Example:
-        >>> d = init()
-        >>> setVarFlag('TEST', 'test', 'blah', d)
-        >>> print getVarFlags('TEST', d)['test']
-        blah
-    """
+    """Gets a variable's flags"""
    return d.getVarFlags(var)

 def delVarFlags(var, d):
-    """Removes a variable's flags
-
-    Example:
-        >>> data = init()
-        >>> setVarFlag('TEST', 'testflag', 1, data)
-        >>> print getVarFlag('TEST', 'testflag', data)
-        1
-        >>> delVarFlags('TEST', data)
-        >>> print getVarFlags('TEST', data)
-        None
-
-    """
+    """Removes a variable's flags"""
    d.delVarFlags(var)

 def keys(d):
-    """Return a list of keys in d
-
-    Example:
-        >>> d = init()
-        >>> setVar('TEST',  1, d)
-        >>> setVar('MOO' ,  2, d)
-        >>> setVarFlag('TEST', 'test', 1, d)
-        >>> keys(d)
-        ['TEST', 'MOO']
-    """
+    """Return a list of keys in d"""
    return d.keys()

-def getData(d):
-    """Returns the data object used"""
-    return d
-
-def setData(newData, d):
-    """Sets the data object to the supplied value"""
-    d = newData
-
-
-##
-## Cookie Monsters' query functions
-##
-def _get_override_vars(d, override):
-    """
-    Internal!!!
-
-    Get the Names of Variables that have a specific
-    override. This function returns a iterable
-    Set or an empty list
-    """
-    return []
-
-def _get_var_flags_triple(d):
-    """
-    Internal!!!
-
-    """
-    return []

 __expand_var_regexp__ = re.compile(r"\${[^{}]+}")
 __expand_python_regexp__ = re.compile(r"\${@.+?}")

 def expand(s, d, varname = None):
-    """Variable expansion using the data store.
-
-    Example:
-        Standard expansion:
-        >>> d = init()
-        >>> setVar('A', 'sshd', d)
-        >>> print expand('/usr/bin/${A}', d)
-        /usr/bin/sshd
-
-        Python expansion:
-        >>> d = init()
-        >>> print expand('result: ${@37 * 72}', d)
-        result: 2664
-
-        Shell expansion:
-        >>> d = init()
-        >>> print expand('${TARGET_MOO}', d)
-        ${TARGET_MOO}
-        >>> setVar('TARGET_MOO', 'yupp', d)
-        >>> print expand('${TARGET_MOO}',d)
-        yupp
-        >>> setVar('SRC_URI', 'http://somebug.${TARGET_MOO}', d)
-        >>> delVar('TARGET_MOO', d)
-        >>> print expand('${SRC_URI}', d)
-        http://somebug.${TARGET_MOO}
-    """
+    """Variable expansion using the data store"""
    return d.expand(s, varname)

 def expandKeys(alterdata, readdata = None):
    if readdata == None:
        readdata = alterdata

+    todolist = {}
    for key in keys(alterdata):
        if not '${' in key:
            continue
@@ -276,281 +150,181 @@ def expandKeys(alterdata, readdata = None):
        ekey = expand(key, readdata)
        if key == ekey:
            continue
-        val = getVar(key, alterdata)
-        if val is None:
-            continue
-#        import copy
-#        setVarFlags(ekey, copy.copy(getVarFlags(key, readdata)), alterdata)
-        setVar(ekey, val, alterdata)
+        todolist[key] = ekey

-        for i in ('_append', '_prepend'):
-            dest = getVarFlag(ekey, i, alterdata) or []
-            src = getVarFlag(key, i, readdata) or []
-            dest.extend(src)
-            setVarFlag(ekey, i, dest, alterdata)
+    # These two for loops are split for performance to maximise the
+    # usefulness of the expand cache

-        delVar(key, alterdata)
-
-def expandData(alterdata, readdata = None):
-    """For each variable in alterdata, expand it, and update the var contents.
-       Replacements use data from readdata.
-
-    Example:
-        >>> a=init()
-        >>> b=init()
-        >>> setVar("dlmsg", "dl_dir is ${DL_DIR}", a)
-        >>> setVar("DL_DIR", "/path/to/whatever", b)
-        >>> expandData(a, b)
-        >>> print getVar("dlmsg", a)
-        dl_dir is /path/to/whatever
-       """
-    if readdata == None:
-        readdata = alterdata
-
-    for key in keys(alterdata):
-        val = getVar(key, alterdata)
-        if type(val) is not types.StringType:
-            continue
-        expanded = expand(val, readdata)
-#       print "key is %s, val is %s, expanded is %s" % (key, val, expanded)
-        if val != expanded:
-            setVar(key, expanded, alterdata)
-
-import os
+    for key in todolist:
+        ekey = todolist[key]
+        renameVar(key, ekey, alterdata)

 def inheritFromOS(d):
    """Inherit variables from the environment."""
-#   fakeroot needs to be able to set these
-    non_inherit_vars = [ "LD_LIBRARY_PATH", "LD_PRELOAD" ]
    for s in os.environ.keys():
-        if not s in non_inherit_vars:
-            try:
-                setVar(s, os.environ[s], d)
-                setVarFlag(s, 'matchesenv', '1', d)
-            except TypeError:
-                pass
-
-import sys
+        try:
+            setVar(s, os.environ[s], d)
+            setVarFlag(s, "export", True, d)
+        except TypeError:
+            pass

 def emit_var(var, o=sys.__stdout__, d = init(), all=False):
    """Emit a variable to be sourced by a shell."""
    if getVarFlag(var, "python", d):
        return 0

+    export = getVarFlag(var, "export", d)
+    unexport = getVarFlag(var, "unexport", d)
+    func = getVarFlag(var, "func", d)
+    if not all and not export and not unexport and not func:
+        return 0
+
    try:
        if all:
            oval = getVar(var, d, 0)
        val = getVar(var, d, 1)
-    except KeyboardInterrupt:
+    except (KeyboardInterrupt, bb.build.FuncFailed):
        raise
-    except:
-        excname = str(sys.exc_info()[0])
-        if excname == "bb.build.FuncFailed":
-            raise
-        o.write('# expansion of %s threw %s\n' % (var, excname))
+    except Exception, exc:
+        o.write('# expansion of %s threw %s: %s\n' % (var, exc.__class__.__name__, str(exc)))
        return 0

    if all:
        o.write('# %s=%s\n' % (var, oval))

-    if type(val) is not types.StringType:
-        return 0
-
-    if getVarFlag(var, 'matchesenv', d):
-        return 0
-
    if (var.find("-") != -1 or var.find(".") != -1 or var.find('{') != -1 or var.find('}') != -1 or var.find('+') != -1) and not all:
        return 0

-    val.rstrip()
-    if not val:
-        return 0
-	
    varExpanded = expand(var, d)

-    if getVarFlag(var, "func", d):
-#       NOTE: should probably check for unbalanced {} within the var
-        o.write("%s() {\n%s\n}\n" % (varExpanded, val))
-    else:
-        if getVarFlag(var, "unexport", d):
-            o.write('unset %s\n' % varExpanded)
-            return 1
-        if getVarFlag(var, "export", d):
-            o.write('export ')
-        else:
-            if not all:
-                return 0
-#       if we're going to output this within doublequotes,
-#       to a shell, we need to escape the quotes in the var
-        alter = re.sub('"', '\\"', val.strip())
-        o.write('%s="%s"\n' % (varExpanded, alter))
-    return 1
+    if unexport:
+        o.write('unset %s\n' % varExpanded)
+        return 1

+    if not val:
+        return 0
+
+    val = str(val)
+
+    if func:
+        # NOTE: should probably check for unbalanced {} within the var
+        o.write("%s() {\n%s\n}\n" % (varExpanded, val))
+        return 1
+
+    if export:
+        o.write('export ')
+
+    # if we're going to output this within doublequotes,
+    # to a shell, we need to escape the quotes in the var
+    alter = re.sub('"', '\\"', val.strip())
+    o.write('%s="%s"\n' % (varExpanded, alter))
+    return 1

 def emit_env(o=sys.__stdout__, d = init(), all=False):
    """Emits all items in the data store in a format such that it can be sourced by a shell."""

-    env = keys(d)
+    isfunc = lambda key: bool(d.getVarFlag(key, "func"))
+    keys = sorted((key for key in d.keys() if not key.startswith("__")), key=isfunc)
+    grouped = groupby(keys, isfunc)
+    for isfunc, keys in grouped:
+        for key in keys:
+            emit_var(key, o, d, all and not isfunc) and o.write('\n')

-    for e in env:
-        if getVarFlag(e, "func", d):
-            continue
-        emit_var(e, o, d, all) and o.write('\n')
+def export_vars(d):
+    keys = (key for key in d.keys() if d.getVarFlag(key, "export"))
+    ret = {}
+    for k in keys:
+        try:
+            v = d.getVar(k, True)
+            if v: 
+                ret[k] = v
+        except (KeyboardInterrupt, bb.build.FuncFailed):
+            raise
+        except Exception, exc:
+            pass
+    return ret

-    for e in env:
-        if not getVarFlag(e, "func", d):
-            continue
-        emit_var(e, o, d) and o.write('\n')
+def emit_func(func, o=sys.__stdout__, d = init()):
+    """Emits all items in the data store in a format such that it can be sourced by a shell."""
+
+    keys = (key for key in d.keys() if not key.startswith("__") and not d.getVarFlag(key, "func"))
+    for key in keys:
+        emit_var(key, o, d, False) and o.write('\n')
+
+    emit_var(func, o, d, False) and o.write('\n')    
+    newdeps = bb.codeparser.ShellParser().parse_shell(d.getVar(func, True))
+    seen = set()
+    while newdeps:
+        deps = newdeps
+        seen |= deps
+        newdeps = set()
+        for dep in deps:
+            if bb.data.getVarFlag(dep, "func", d):
+               emit_var(dep, o, d, False) and o.write('\n')
+               newdeps |=  bb.codeparser.ShellParser().parse_shell(d.getVar(dep, True))
+        newdeps -= seen

 def update_data(d):
-    """Modifies the environment vars according to local overrides and commands.
-    Examples:
-        Appending to a variable:
-        >>> d = init()
-        >>> setVar('TEST', 'this is a', d)
-        >>> setVar('TEST_append', ' test', d)
-        >>> setVar('TEST_append', ' of the emergency broadcast system.', d)
-        >>> update_data(d)
-        >>> print getVar('TEST', d)
-        this is a test of the emergency broadcast system.
+    """Performs final steps upon the datastore, including application of overrides"""
+    d.finalize()

-        Prepending to a variable:
-        >>> setVar('TEST', 'virtual/libc', d)
-        >>> setVar('TEST_prepend', 'virtual/tmake ', d)
-        >>> setVar('TEST_prepend', 'virtual/patcher ', d)
-        >>> update_data(d)
-        >>> print getVar('TEST', d)
-        virtual/patcher virtual/tmake virtual/libc
+def build_dependencies(key, keys, shelldeps, d):
+    deps = set()
+    try:
+        if d.getVarFlag(key, "func"):
+            if d.getVarFlag(key, "python"):
+                parsedvar = d.expandWithRefs(d.getVar(key, False), key)
+                parser = bb.codeparser.PythonParser()
+                parser.parse_python(parsedvar.value)
+                deps = deps | parser.references
+            else:
+                parsedvar = d.expandWithRefs(d.getVar(key, False), key)
+                parser = bb.codeparser.ShellParser()
+                parser.parse_shell(parsedvar.value)
+                deps = deps | shelldeps
+            deps = deps | parsedvar.references
+            deps = deps | (keys & parser.execs) | (keys & parsedvar.execs)
+        else:
+            parser = d.expandWithRefs(d.getVar(key, False), key)
+            deps |= parser.references
+            deps = deps | (keys & parser.execs)
+        deps |= set((d.getVarFlag(key, "vardeps") or "").split())
+    except:
+        bb.note("Error expanding variable %s" % key) 
+        raise
+    return deps
+    #bb.note("Variable %s references %s and calls %s" % (key, str(deps), str(execs)))
+    #d.setVarFlag(key, "vardeps", deps)

-        Overrides:
-        >>> setVar('TEST_arm', 'target', d)
-        >>> setVar('TEST_ramses', 'machine', d)
-        >>> setVar('TEST_local', 'local', d)
-        >>> setVar('OVERRIDES', 'arm', d)
+def generate_dependencies(d):

-        >>> setVar('TEST', 'original', d)
-        >>> update_data(d)
-        >>> print getVar('TEST', d)
-        target
+    keys = set(key for key in d.keys() if not key.startswith("__"))
+    shelldeps = set(key for key in keys if d.getVarFlag(key, "export") and not d.getVarFlag(key, "unexport"))

-        >>> setVar('OVERRIDES', 'arm:ramses:local', d)
-        >>> setVar('TEST', 'original', d)
-        >>> update_data(d)
-        >>> print getVar('TEST', d)
-        local
+    deps = {}
+    taskdeps = {}

-        CopyMonster:
-        >>> e = d.createCopy()
-        >>> setVar('TEST_foo', 'foo', e)
-        >>> update_data(e)
-        >>> print getVar('TEST', e)
-        local
-
-        >>> setVar('OVERRIDES', 'arm:ramses:local:foo', e)
-        >>> update_data(e)
-        >>> print getVar('TEST', e)
-        foo
-
-        >>> f = d.createCopy()
-        >>> setVar('TEST_moo', 'something', f)
-        >>> setVar('OVERRIDES', 'moo:arm:ramses:local:foo', e)
-        >>> update_data(e)
-        >>> print getVar('TEST', e)
-        foo
-
-
-        >>> h = init()
-        >>> setVar('SRC_URI', 'file://append.foo;patch=1 ', h)
-        >>> g = h.createCopy()
-        >>> setVar('SRC_URI_append_arm', 'file://other.foo;patch=1', g)
-        >>> setVar('OVERRIDES', 'arm:moo', g)
-        >>> update_data(g)
-        >>> print getVar('SRC_URI', g)
-        file://append.foo;patch=1 file://other.foo;patch=1
-
-    """
-    bb.msg.debug(2, bb.msg.domain.Data, "update_data()")
-
-    # now ask the cookie monster for help
-    #print "Cookie Monster"
-    #print "Append/Prepend %s" % d._special_values
-    #print "Overrides      %s" % d._seen_overrides
-
-    overrides = (getVar('OVERRIDES', d, 1) or "").split(':') or []
-
-    #
-    # Well let us see what breaks here. We used to iterate
-    # over each variable and apply the override and then
-    # do the line expanding.
-    # If we have bad luck - which we will have - the keys
-    # where in some order that is so important for this
-    # method which we don't have anymore.
-    # Anyway we will fix that and write test cases this
-    # time.
-
-    #
-    # First we apply all overrides
-    # Then  we will handle _append and _prepend
-    #
-
-    for o in overrides:
-        # calculate '_'+override
-        l    = len(o)+1
-
-        # see if one should even try
-        if not d._seen_overrides.has_key(o):
-            continue
-
-        vars = d._seen_overrides[o]
-        for var in vars:
-            name = var[:-l]
-            try:
-                d[name] = d[var]
-            except:
-                bb.msg.note(1, bb.msg.domain.Data, "Untracked delVar")
-
-    # now on to the appends and prepends
-    if d._special_values.has_key('_append'):
-        appends = d._special_values['_append'] or []
-        for append in appends:
-            for (a, o) in getVarFlag(append, '_append', d) or []:
-                # maybe the OVERRIDE was not yet added so keep the append
-                if (o and o in overrides) or not o:
-                    delVarFlag(append, '_append', d)
-                if o and not o in overrides:
-                    continue
-
-                sval = getVar(append,d) or ""
-                sval+=a
-                setVar(append, sval, d)
-
-
-    if d._special_values.has_key('_prepend'):
-        prepends = d._special_values['_prepend'] or []
-
-        for prepend in prepends:
-            for (a, o) in getVarFlag(prepend, '_prepend', d) or []:
-                # maybe the OVERRIDE was not yet added so keep the prepend
-                if (o and o in overrides) or not o:
-                    delVarFlag(prepend, '_prepend', d)
-                if o and not o in overrides:
-                    continue
-
-                sval = a + (getVar(prepend,d) or "")
-                setVar(prepend, sval, d)
+    tasklist = bb.data.getVar('__BBTASKS', d) or []
+    for task in tasklist:
+        deps[task] = build_dependencies(task, keys, shelldeps, d)

+        newdeps = deps[task]
+        seen = set()
+        while newdeps:
+            nextdeps = newdeps
+            seen |= nextdeps
+            newdeps = set()
+            for dep in nextdeps:
+                if dep not in deps:
+                    deps[dep] = build_dependencies(dep, keys, shelldeps, d)
+                newdeps |=  deps[dep]
+            newdeps -= seen
+        taskdeps[task] = seen | newdeps
+        #print "For %s: %s" % (task, str(taskdeps[task]))
+    return taskdeps, deps

 def inherits_class(klass, d):
    val = getVar('__inherit_cache', d) or []
    if os.path.join('classes', '%s.bbclass' % klass) in val:
        return True
    return False
-
-def _test():
-    """Start a doctest run on this module"""
-    import doctest
-    from bb import data
-    doctest.testmod(data)
-
-if __name__ == "__main__":
-    _test()
--- a/bitbake/lib/bb/data_smart.py
+++ b/bitbake/lib/bb/data_smart.py
@@ -28,19 +28,50 @@ BitBake build tools.
 # 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 # Based on functions from the base bb module, Copyright 2003 Holger Schurig

-import copy, os, re, sys, time, types
+import copy, re, sys
 import bb
-from bb   import utils, methodpool
-from COW  import COWDictBase
-from sets import Set
-from new  import classobj
+from bb   import utils
+from bb.COW  import COWDictBase


-__setvar_keyword__ = ["_append","_prepend"]
+__setvar_keyword__ = ["_append", "_prepend"]
 __setvar_regexp__ = re.compile('(?P<base>.*?)(?P<keyword>_append|_prepend)(_(?P<add>.*))?')
 __expand_var_regexp__ = re.compile(r"\${[^{}]+}")
 __expand_python_regexp__ = re.compile(r"\${@.+?}")

+class VariableParse:
+    def __init__(self, varname, d, val = None):
+        self.varname = varname
+        self.d = d
+        self.value = val
+
+        self.references = set()
+        self.execs = set()
+
+    def var_sub(self, match):
+            key = match.group()[2:-1]
+            if self.varname and key:
+                if self.varname == key:
+                    raise Exception("variable %s references itself!" % self.varname)
+            var = self.d.getVar(key, 1)
+            if var is not None:
+                self.references.add(key)
+                return var
+            else:
+                return match.group()
+
+    def python_sub(self, match):
+            code = match.group()[3:-1]
+            codeobj = compile(code.strip(), self.varname or "<expansion>", "eval")
+
+            parser = bb.codeparser.PythonParser()
+            parser.parse_python(code)
+            self.references |= parser.references
+            self.execs |= parser.execs
+
+            value = utils.better_eval(codeobj, {"d": self.d})
+            return str(value)
+

 class DataSmart:
    def __init__(self, special = COWDictBase.copy(), seen = COWDictBase.copy() ):
@@ -52,68 +83,120 @@ class DataSmart:

        self.expand_cache = {}

-    def expand(self,s, varname):
-        def var_sub(match):
-            key = match.group()[2:-1]
-            if varname and key:
-                if varname == key:
-                    raise Exception("variable %s references itself!" % varname)
-            var = self.getVar(key, 1)
-            if var is not None:
-                return var
-            else:
-                return match.group()
+    def expandWithRefs(self, s, varname):

-        def python_sub(match):
-            import bb
-            code = match.group()[3:-1]
-            locals()['d'] = self
-            s = eval(code)
-            if type(s) == types.IntType: s = str(s)
-            return s
-
-        if type(s) is not types.StringType: # sanity check
-            return s
+        if not isinstance(s, basestring): # sanity check
+            return VariableParse(varname, self, s)

        if varname and varname in self.expand_cache:
            return self.expand_cache[varname]

+        varparse = VariableParse(varname, self)
+
        while s.find('${') != -1:
            olds = s
            try:
-                s = __expand_var_regexp__.sub(var_sub, s)
-                s = __expand_python_regexp__.sub(python_sub, s)
-                if s == olds: break
-                if type(s) is not types.StringType: # sanity check
-                    bb.msg.error(bb.msg.domain.Data, 'expansion of %s returned non-string %s' % (olds, s))
+                s = __expand_var_regexp__.sub(varparse.var_sub, s)
+                s = __expand_python_regexp__.sub(varparse.python_sub, s)
+                if s == olds:
+                    break
            except KeyboardInterrupt:
                raise
            except:
                bb.msg.note(1, bb.msg.domain.Data, "%s:%s while evaluating:\n%s" % (sys.exc_info()[0], sys.exc_info()[1], s))
                raise

-        if varname:
-            self.expand_cache[varname] = s
+        varparse.value = s

-        return s
+        if varname:
+            self.expand_cache[varname] = varparse
+
+        return varparse
+
+    def expand(self, s, varname):
+        return self.expandWithRefs(s, varname).value
+    
+
+    def finalize(self):
+        """Performs final steps upon the datastore, including application of overrides"""
+
+        overrides = (self.getVar("OVERRIDES", True) or "").split(":") or []
+
+        #
+        # Well let us see what breaks here. We used to iterate
+        # over each variable and apply the override and then
+        # do the line expanding.
+        # If we have bad luck - which we will have - the keys
+        # where in some order that is so important for this
+        # method which we don't have anymore.
+        # Anyway we will fix that and write test cases this
+        # time.
+
+        #
+        # First we apply all overrides
+        # Then  we will handle _append and _prepend
+        #
+
+        for o in overrides:
+            # calculate '_'+override
+            l = len(o) + 1
+
+            # see if one should even try
+            if o not in self._seen_overrides:
+                continue
+
+            vars = self._seen_overrides[o]
+            for var in vars:
+                name = var[:-l]
+                try:
+                    self[name] = self[var]
+                except Exception:
+                    bb.msg.note(1, bb.msg.domain.Data, "Untracked delVar")
+
+        # now on to the appends and prepends
+        if "_append" in self._special_values:
+            appends = self._special_values["_append"] or []
+            for append in appends:
+                for (a, o) in self.getVarFlag(append, "_append") or []:
+                    # maybe the OVERRIDE was not yet added so keep the append
+                    if (o and o in overrides) or not o:
+                        self.delVarFlag(append, "_append")
+                    if o and not o in overrides:
+                        continue
+
+                    sval = self.getVar(append, False) or ""
+                    sval += a
+                    self.setVar(append, sval)
+
+
+        if "_prepend" in self._special_values:
+            prepends = self._special_values["_prepend"] or []
+
+            for prepend in prepends:
+                for (a, o) in self.getVarFlag(prepend, "_prepend") or []:
+                    # maybe the OVERRIDE was not yet added so keep the prepend
+                    if (o and o in overrides) or not o:
+                        self.delVarFlag(prepend, "_prepend")
+                    if o and not o in overrides:
+                        continue
+
+                    sval = a + (self.getVar(prepend, False) or "")
+                    self.setVar(prepend, sval)

    def initVar(self, var):
        self.expand_cache = {}
        if not var in self.dict:
            self.dict[var] = {}

-    def _findVar(self,var):
-        _dest = self.dict
+    def _findVar(self, var):
+        dest = self.dict
+        while dest:
+            if var in dest:
+                return dest[var]

-        while (_dest and var not in _dest):
-            if not "_data" in _dest:
-                _dest = None
+            if "_data" not in dest:
                break
-            _dest = _dest["_data"]
-
-        if _dest and var in _dest:
-            return _dest[var]
-        return None
+            dest = dest["_data"]

    def _makeShadowCopy(self, var):
        if var in self.dict:
@@ -126,7 +209,7 @@ class DataSmart:
        else:
            self.initVar(var)

-    def setVar(self,var,value):
+    def setVar(self, var, value):
        self.expand_cache = {}
        match  = __setvar_regexp__.match(var)
        if match and match.group("keyword") in __setvar_keyword__:
@@ -141,52 +224,72 @@ class DataSmart:
            # pay the cookie monster
            try:
                self._special_values[keyword].add( base )
-            except:
-                self._special_values[keyword] = Set()
+            except KeyError:
+                self._special_values[keyword] = set()
                self._special_values[keyword].add( base )

            return

        if not var in self.dict:
            self._makeShadowCopy(var)
-        if self.getVarFlag(var, 'matchesenv'):
-            self.delVarFlag(var, 'matchesenv')
-            self.setVarFlag(var, 'export', 1)

        # more cookies for the cookie monster
        if '_' in var:
            override = var[var.rfind('_')+1:]
-            if not self._seen_overrides.has_key(override):
-                self._seen_overrides[override] = Set()
+            if override not in self._seen_overrides:
+                self._seen_overrides[override] = set()
            self._seen_overrides[override].add( var )

        # setting var
        self.dict[var]["content"] = value

-    def getVar(self,var,exp):
-        value = self.getVarFlag(var,"content")
+    def getVar(self, var, exp):
+        value = self.getVarFlag(var, "content")

        if exp and value:
-            return self.expand(value,var)
+            return self.expand(value, var)
        return value

-    def delVar(self,var):
+    def renameVar(self, key, newkey):
+        """
+        Rename the variable key to newkey
+        """
+        val = self.getVar(key, 0)
+        if val is not None:
+            self.setVar(newkey, val)
+
+        for i in ('_append', '_prepend'):
+            src = self.getVarFlag(key, i)
+            if src is None:
+                continue
+
+            dest = self.getVarFlag(newkey, i) or []
+            dest.extend(src)
+            self.setVarFlag(newkey, i, dest)
+
+            if i in self._special_values and key in self._special_values[i]:
+                self._special_values[i].remove(key)
+                self._special_values[i].add(newkey)
+
+        self.delVar(key)
+
+    def delVar(self, var):
        self.expand_cache = {}
        self.dict[var] = {}

-    def setVarFlag(self,var,flag,flagvalue):
+    def setVarFlag(self, var, flag, flagvalue):
        if not var in self.dict:
            self._makeShadowCopy(var)
        self.dict[var][flag] = flagvalue

-    def getVarFlag(self,var,flag):
+    def getVarFlag(self, var, flag):
        local_var = self._findVar(var)
        if local_var:
            if flag in local_var:
                return copy.copy(local_var[flag])
        return None

-    def delVarFlag(self,var,flag):
+    def delVarFlag(self, var, flag):
        local_var = self._findVar(var)
        if not local_var:
            return
@@ -196,31 +299,31 @@ class DataSmart:
        if var in self.dict and flag in self.dict[var]:
            del self.dict[var][flag]

-    def setVarFlags(self,var,flags):
+    def setVarFlags(self, var, flags):
        if not var in self.dict:
            self._makeShadowCopy(var)

-        for i in flags.keys():
+        for i in flags:
            if i == "content":
                continue
            self.dict[var][i] = flags[i]

-    def getVarFlags(self,var):
+    def getVarFlags(self, var):
        local_var = self._findVar(var)
        flags = {}

        if local_var:
-            for i in self.dict[var].keys():
+            for i in local_var:
                if i == "content":
                    continue
-                flags[i] = self.dict[var][i]
+                flags[i] = local_var[i]

        if len(flags) == 0:
            return None
        return flags


-    def delVarFlags(self,var):
+    def delVarFlags(self, var):
        if not var in self.dict:
            self._makeShadowCopy(var)

@@ -250,21 +353,19 @@ class DataSmart:
    def keys(self):
        def _keys(d, mykey):
            if "_data" in d:
-                _keys(d["_data"],mykey)
+                _keys(d["_data"], mykey)

            for key in d.keys():
                if key != "_data":
                    mykey[key] = None
        keytab = {}
-        _keys(self.dict,keytab)
+        _keys(self.dict, keytab)
        return keytab.keys()

-    def __getitem__(self,item):
+    def __getitem__(self, item):
        #print "Warning deprecated"
        return self.getVar(item, False)

-    def __setitem__(self,var,data):
+    def __setitem__(self, var, data):
        #print "Warning deprecated"
-        self.setVar(var,data)
-
-
+        self.setVar(var, data)
--- a/bitbake/lib/bb/event.py
+++ b/bitbake/lib/bb/event.py
@@ -22,100 +22,130 @@ BitBake build tools.
 # with this program; if not, write to the Free Software Foundation, Inc.,
 # 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.

-import os, re
+import os, sys
+import warnings
 import bb.utils
+import pickle
+
+# This is the pid for which we should generate the event. This is set when
+# the runqueue forks off.
+worker_pid = 0
+worker_pipe = None
+useStdout = True

 class Event:
    """Base class for events"""
-    type = "Event"

-    def __init__(self, d):
-        self._data = d
-
-    def getData(self):
-        return self._data
-
-    def setData(self, data):
-        self._data = data
-
-    data = property(getData, setData, None, "data property")
+    def __init__(self):
+        self.pid = worker_pid

 NotHandled = 0
-Handled = 1
+Handled    = 1

 Registered        = 10
 AlreadyRegistered = 14

 # Internal
-_handlers = []
-_handlers_dict = {}
+_handlers = {}
+_ui_handlers = {}
+_ui_handler_seq = 0

-def tmpHandler(event):
-    """Default handler for code events"""
-    return NotHandled
+# For compatibility
+bb.utils._context["NotHandled"] = NotHandled
+bb.utils._context["Handled"] = Handled

-def defaultTmpHandler():
-    tmp = "def tmpHandler(e):\n\t\"\"\"heh\"\"\"\n\treturn NotHandled"
-    comp = bb.utils.better_compile(tmp, "tmpHandler(e)", "bb.event.defaultTmpHandler")
-    return comp
+def fire_class_handlers(event, d):
+    import bb.msg
+    if isinstance(event, bb.msg.MsgBase):
+        return

-def fire(event):
-    """Fire off an Event"""
-    for h in _handlers:
+    for handler in _handlers:
+        h = _handlers[handler]
+        event.data = d
        if type(h).__name__ == "code":
-            exec(h)
-            if tmpHandler(event) == Handled:
-                return Handled
+            locals = {"e": event}
+            bb.utils.simple_exec(h, locals)
+            ret = bb.utils.better_eval("tmpHandler(e)", locals)
+            if ret is not None:
+                warnings.warn("Using Handled/NotHandled in event handlers is deprecated",
+                              DeprecationWarning, stacklevel = 2)
        else:
-            if h(event) == Handled:
-                return Handled
-    return NotHandled
+            h(event)
+        del event.data
+
+def fire_ui_handlers(event, d):
+    errors = []
+    for h in _ui_handlers:
+        #print "Sending event %s" % event
+        try:
+             # We use pickle here since it better handles object instances
+             # which xmlrpc's marshaller does not. Events *must* be serializable
+             # by pickle.
+            _ui_handlers[h].event.send((pickle.dumps(event)))
+        except:
+            errors.append(h)
+    for h in errors:
+        del _ui_handlers[h]
+
+def fire(event, d):
+    """Fire off an Event"""
+
+    # We can fire class handlers in the worker process context and this is
+    # desired so they get the task based datastore.
+    # UI handlers need to be fired in the server context so we defer this. They
+    # don't have a datastore so the datastore context isn't a problem.
+
+    fire_class_handlers(event, d)
+    if worker_pid != 0:
+        worker_fire(event, d)
+    else:
+        fire_ui_handlers(event, d)
+
+def worker_fire(event, d):
+    data = "<event>" + pickle.dumps(event) + "</event>"
+    worker_pipe.write(data)
+    worker_pipe.flush()
+
+def fire_from_worker(event, d):
+    if not event.startswith("<event>") or not event.endswith("</event>"):
+        print("Error, not an event %s" % event)
+        return
+    #print "Got event %s" % event
+    event = pickle.loads(event[7:-8])
+    fire_ui_handlers(event, d)

 def register(name, handler):
    """Register an Event handler"""

    # already registered
-    if name in _handlers_dict:
+    if name in _handlers:
        return AlreadyRegistered

    if handler is not None:
-#       handle string containing python code
+        # handle string containing python code
        if type(handler).__name__ == "str":
-            _registerCode(handler)
+            tmp = "def tmpHandler(e):\n%s" % handler
+            comp = bb.utils.better_compile(tmp, "tmpHandler(e)", "bb.event._registerCode")
+            _handlers[name] = comp
        else:
-            _handlers.append(handler)
+            _handlers[name] = handler

-        _handlers_dict[name] = 1
        return Registered

-def _registerCode(handlerStr):
-    """Register a 'code' Event.
-       Deprecated interface; call register instead.
-
-       Expects to be passed python code as a string, which will
-       be passed in turn to compile() and then exec().  Note that
-       the code will be within a function, so should have had
-       appropriate tabbing put in place."""
-    tmp = "def tmpHandler(e):\n%s" % handlerStr
-    comp = bb.utils.better_compile(tmp, "tmpHandler(e)", "bb.event._registerCode")
-#   prevent duplicate registration
-    _handlers.append(comp)
-
 def remove(name, handler):
    """Remove an Event handler"""
+    _handlers.pop(name)

-    _handlers_dict.pop(name)
-    if type(handler).__name__ == "str":
-        return _removeCode(handler)
-    else:
-        _handlers.remove(handler)
+def register_UIHhandler(handler):
+    bb.event._ui_handler_seq = bb.event._ui_handler_seq + 1
+    _ui_handlers[_ui_handler_seq] = handler
+    bb.event.useStdout = False
+    return _ui_handler_seq

-def _removeCode(handlerStr):
-    """Remove a 'code' Event handler
-       Deprecated interface; call remove instead."""
-    tmp = "def tmpHandler(e):\n%s" % handlerStr
-    comp = bb.utils.better_compile(tmp, "tmpHandler(e)", "bb.event._removeCode")
-    _handlers.remove(comp)
+def unregister_UIHhandler(handlerNum):
+    if handlerNum in _ui_handlers:
+        del _ui_handlers[handlerNum]
+    return

 def getName(e):
    """Returns the name of a class or class instance"""
@@ -124,30 +154,40 @@ def getName(e):
    else:
        return e.__name__

+class ConfigParsed(Event):
+    """Configuration Parsing Complete"""

-class PkgBase(Event):
-    """Base class for package events"""
+class RecipeParsed(Event):
+    """ Recipe Parsing Complete """

-    def __init__(self, t, d):
-        self._pkg = t
-        Event.__init__(self, d)
+    def __init__(self, fn):
+        self.fn = fn
+        Event.__init__(self)

-    def getPkg(self):
-        return self._pkg
+class StampUpdate(Event):
+    """Trigger for any adjustment of the stamp files to happen"""

-    def setPkg(self, pkg):
-        self._pkg = pkg
+    def __init__(self, targets, stampfns):
+        self._targets = targets
+        self._stampfns = stampfns
+        Event.__init__(self)

-    pkg = property(getPkg, setPkg, None, "pkg property")
+    def getStampPrefix(self):
+        return self._stampfns

+    def getTargets(self):
+        return self._targets
+
+    stampPrefix = property(getStampPrefix)
+    targets = property(getTargets)

 class BuildBase(Event):
    """Base class for bbmake run events"""

-    def __init__(self, n, p, c, failures = 0):
+    def __init__(self, n, p, failures = 0):
        self._name = n
        self._pkgs = p
-        Event.__init__(self, c)
+        Event.__init__(self)
        self._failures = failures

    def getPkgs(self):
@@ -179,32 +219,7 @@ class BuildBase(Event):
    cfg = property(getCfg, setCfg, None, "cfg property")


-class DepBase(PkgBase):
-    """Base class for dependency events"""

-    def __init__(self, t, data, d):
-        self._dep = d
-        PkgBase.__init__(self, t, data)
-
-    def getDep(self):
-        return self._dep
-
-    def setDep(self, dep):
-        self._dep = dep
-
-    dep = property(getDep, setDep, None, "dep property")
-
-
-class PkgStarted(PkgBase):
-    """Package build started"""
-
-
-class PkgFailed(PkgBase):
-    """Package build failed"""
-
-
-class PkgSucceeded(PkgBase):
-    """Package build completed"""


 class BuildStarted(BuildBase):
@@ -215,20 +230,16 @@ class BuildCompleted(BuildBase):
    """bbmake build run completed"""


-class UnsatisfiedDep(DepBase):
-    """Unsatisfied Dependency"""


-class RecursiveDep(DepBase):
-    """Recursive Dependency"""
-
 class NoProvider(Event):
    """No Provider for an Event"""

-    def __init__(self, item, data,runtime=False):
-        Event.__init__(self, data)
+    def __init__(self, item, runtime=False, dependees=None):
+        Event.__init__(self)
        self._item = item
        self._runtime = runtime
+        self._dependees = dependees

    def getItem(self):
        return self._item
@@ -239,8 +250,8 @@ class NoProvider(Event):
 class MultipleProviders(Event):
    """Multiple Providers"""

-    def  __init__(self, item, candidates, data, runtime = False):
-        Event.__init__(self, data)
+    def  __init__(self, item, candidates, runtime = False):
+        Event.__init__(self)
        self._item = item
        self._candidates = candidates
        self._is_runtime = runtime
@@ -262,3 +273,28 @@ class MultipleProviders(Event):
        Get the possible Candidates for a PROVIDER.
        """
        return self._candidates
+
+class ParseProgress(Event):
+    """
+    Parsing Progress Event
+    """
+
+    def __init__(self, cached, parsed, skipped, masked, virtuals, errors, total):
+        Event.__init__(self)
+        self.cached = cached
+        self.parsed = parsed
+        self.skipped = skipped
+        self.virtuals = virtuals
+        self.masked = masked
+        self.errors = errors
+        self.sofar = cached + parsed
+        self.total = total
+
+class DepTreeGenerated(Event):
+    """
+    Event when a dependency tree has been generated
+    """
+
+    def __init__(self, depgraph):
+        Event.__init__(self)
+        self._depgraph = depgraph
--- a/bitbake/lib/bb/fetch/init.py
+++ b/bitbake/lib/bb/fetch/init.py
@@ -24,9 +24,15 @@ BitBake build tools.
 #
 # Based on functions from the base bb module, Copyright 2003 Holger Schurig

+from __future__ import absolute_import
+from __future__ import print_function
 import os, re
 import bb
 from   bb import data
+from   bb import persist_data
+
+class MalformedUrl(Exception):
+    """Exception raised when encountering an invalid url"""

 class FetchError(Exception):
    """Exception raised when a download fails"""
@@ -43,20 +49,85 @@ class ParameterError(Exception):
 class MD5SumError(Exception):
    """Exception raised when a MD5SUM of a file does not match the expected one"""

+class InvalidSRCREV(Exception):
+    """Exception raised when an invalid SRCREV is encountered"""
+
+def decodeurl(url):
+    """Decodes an URL into the tokens (scheme, network location, path,
+    user, password, parameters).
+    """
+
+    m = re.compile('(?P<type>[^:]*)://((?P<user>.+)@)?(?P<location>[^;]+)(;(?P<parm>.*))?').match(url)
+    if not m:
+        raise MalformedUrl(url)
+
+    type = m.group('type')
+    location = m.group('location')
+    if not location:
+        raise MalformedUrl(url)
+    user = m.group('user')
+    parm = m.group('parm')
+
+    locidx = location.find('/')
+    if locidx != -1 and type.lower() != 'file':
+        host = location[:locidx]
+        path = location[locidx:]
+    else:
+        host = ""
+        path = location
+    if user:
+        m = re.compile('(?P<user>[^:]+)(:?(?P<pswd>.*))').match(user)
+        if m:
+            user = m.group('user')
+            pswd = m.group('pswd')
+    else:
+        user = ''
+        pswd = ''
+
+    p = {}
+    if parm:
+        for s in parm.split(';'):
+            s1, s2 = s.split('=')
+            p[s1] = s2
+
+    return (type, host, path, user, pswd, p)
+
+def encodeurl(decoded):
+    """Encodes a URL from tokens (scheme, network location, path,
+    user, password, parameters).
+    """
+
+    (type, host, path, user, pswd, p) = decoded
+
+    if not type or not path:
+        raise MissingParameterError("Type or path url components missing when encoding %s" % decoded)
+    url = '%s://' % type
+    if user:
+        url += "%s" % user
+        if pswd:
+            url += ":%s" % pswd
+        url += "@"
+    if host:
+        url += "%s" % host
+    url += "%s" % path
+    if p:
+        for parm in p:
+            url += ";%s=%s" % (parm, p[parm])
+
+    return url
+
 def uri_replace(uri, uri_find, uri_replace, d):
 #   bb.msg.note(1, bb.msg.domain.Fetcher, "uri_replace: operating on %s" % uri)
    if not uri or not uri_find or not uri_replace:
        bb.msg.debug(1, bb.msg.domain.Fetcher, "uri_replace: passed an undefined value, not replacing")
-    uri_decoded = list(bb.decodeurl(uri))
-    uri_find_decoded = list(bb.decodeurl(uri_find))
-    uri_replace_decoded = list(bb.decodeurl(uri_replace))
-    result_decoded = ['','','','','',{}]
+    uri_decoded = list(decodeurl(uri))
+    uri_find_decoded = list(decodeurl(uri_find))
+    uri_replace_decoded = list(decodeurl(uri_replace))
+    result_decoded = ['', '', '', '', '', {}]
    for i in uri_find_decoded:
        loc = uri_find_decoded.index(i)
        result_decoded[loc] = uri_decoded[loc]
-        import types
-        if type(i) == types.StringType:
-            import re
+        if isinstance(i, basestring):
            if (re.match(i, uri_decoded[loc])):
                result_decoded[loc] = re.sub(i, uri_replace_decoded[loc], uri_decoded[loc])
                if uri_find_decoded.index(i) == 2:
@@ -69,83 +140,404 @@ def uri_replace(uri, uri_find, uri_replace, d):
 #               bb.msg.note(1, bb.msg.domain.Fetcher, "uri_replace: no match")
                return uri
 #           else:
-#               for j in i.keys():
+#               for j in i:
 #                   FIXME: apply replacements against options
-    return bb.encodeurl(result_decoded)
+    return encodeurl(result_decoded)

 methods = []
-urldata = {}
+urldata_cache = {}
+saved_headrevs = {}
+persistent_database_connection = {}

-def init(urls = [], d = None):
-    if d == None:
-        bb.msg.debug(2, bb.msg.domain.Fetcher, "BUG init called with None as data object!!!")
-        return
+def fetcher_init(d):
+    """
+    Called to initialize the fetchers once the configuration data is known.
+    Calls before this must not hit the cache.
+    """
+    pd = persist_data.PersistData(d, persistent_database_connection)
+    # When to drop SCM head revisions controlled by user policy
+    srcrev_policy = bb.data.getVar('BB_SRCREV_POLICY', d, 1) or "clear"
+    if srcrev_policy == "cache":
+        bb.msg.debug(1, bb.msg.domain.Fetcher, "Keeping SRCREV cache due to cache policy of: %s" % srcrev_policy)
+    elif srcrev_policy == "clear":
+        bb.msg.debug(1, bb.msg.domain.Fetcher, "Clearing SRCREV cache due to cache policy of: %s" % srcrev_policy)
+        try:
+            bb.fetch.saved_headrevs = pd.getKeyValues("BB_URI_HEADREVS")
+        except:
+            pass
+        pd.delDomain("BB_URI_HEADREVS")
+    else:
+        raise FetchError("Invalid SRCREV cache policy of: %s" % srcrev_policy)

    for m in methods:
-        m.urls = []
+        if hasattr(m, "init"):
+            m.init(d)
+
+    # Make sure our domains exist
+    pd.addDomain("BB_URI_HEADREVS")
+    pd.addDomain("BB_URI_LOCALCOUNT")
+
+def fetcher_compare_revisons(d):
+    """
+    Compare the revisions in the persistant cache with current values and
+    return true/false on whether they've changed.
+    """
+
+    pd = persist_data.PersistData(d, persistent_database_connection)
+    data = pd.getKeyValues("BB_URI_HEADREVS")
+    data2 = bb.fetch.saved_headrevs
+
+    changed = False
+    for key in data:
+        if key not in data2 or data2[key] != data[key]:
+            bb.msg.debug(1, bb.msg.domain.Fetcher, "%s changed" % key)
+            changed = True
+            return True
+        else:
+            bb.msg.debug(2, bb.msg.domain.Fetcher, "%s did not change" % key)
+    return False
+
+# Function call order is usually:
+#   1. init
+#   2. go
+#   3. localpaths
+# localpath can be called at any time
+
+def init(urls, d, setup = True):
+    urldata = {}
+
+    fn = bb.data.getVar('FILE', d, 1)
+    if fn in urldata_cache:
+        urldata = urldata_cache[fn]
+
+    for url in urls:
+        if url not in urldata:
+            urldata[url] = FetchData(url, d)
+
+    if setup:
+        for url in urldata:
+            if not urldata[url].setup:
+                urldata[url].setup_localpath(d)
+
+    urldata_cache[fn] = urldata
+    return urldata
+
+def mirror_from_string(data):
+    return [ i.split() for i in (data or "").replace('\\n','\n').split('\n') if i ]
+
+def removefile(f):
+    try:
+        os.remove(f)
+    except:
+        pass
+
+def go(d, urls = None):
+    """
+    Fetch all urls
+    init must have previously been called
+    """
+    if not urls:
+        urls = d.getVar("SRC_URI", 1).split()
+    urldata = init(urls, d, True)

    for u in urls:
-        ud = initdata(u, d)
-        if ud.method:
-            ud.method.urls.append(u)
+        ud = urldata[u]
+        m = ud.method
+        localpath = ""

-def initdata(url, d):
-    fn = bb.data.getVar('FILE', d, 1)
-    if fn not in urldata:
-        urldata[fn] = {}
-    if url not in urldata[fn]:
-        ud = FetchData()
-        (ud.type, ud.host, ud.path, ud.user, ud.pswd, ud.parm) = bb.decodeurl(data.expand(url, d))
-        ud.date = Fetch.getSRCDate(ud, d)
-        for m in methods:
-            if m.supports(url, ud, d):
-                ud.localpath = m.localpath(url, ud, d)
-                ud.md5 = ud.localpath + '.md5'
-                # if user sets localpath for file, use it instead.
-                if "localpath" in ud.parm:
-                    ud.localpath = ud.parm["localpath"]
-                ud.method = m
-                break
-        urldata[fn][url] = ud
-    return urldata[fn][url]
+        if not ud.localfile:
+            continue

-def go(d):
-    """Fetch all urls"""
-    fn = bb.data.getVar('FILE', d, 1)
-    for m in methods:
-        for u in m.urls:
-            ud = urldata[fn][u]
-            if ud.localfile and not m.forcefetch(u, ud, d) and os.path.exists(urldata[fn][u].md5):
-                # File already present along with md5 stamp file
-                # Touch md5 file to show activity
+        lf = bb.utils.lockfile(ud.lockfile)
+
+        if m.try_premirror(u, ud, d):
+            # First try fetching uri, u, from PREMIRRORS
+            mirrors = mirror_from_string(bb.data.getVar('PREMIRRORS', d, True))
+            localpath = try_mirrors(d, u, mirrors, False, m.forcefetch(u, ud, d))
+        elif os.path.exists(ud.localfile):
+            localpath = ud.localfile
+
+        # Need to re-test forcefetch() which will return true if our copy is too old
+        if m.forcefetch(u, ud, d) or not localpath:
+            # Next try fetching from the original uri, u
+            try:
+                m.go(u, ud, d)
+                localpath = ud.localpath
+            except FetchError:
+                # Remove any incomplete file
+                removefile(ud.localpath)
+                # Finally, try fetching uri, u, from MIRRORS
+                mirrors = mirror_from_string(bb.data.getVar('MIRRORS', d, True))
+                localpath = try_mirrors (d, u, mirrors)
+                if not localpath or not os.path.exists(localpath):
+                    raise FetchError("Unable to fetch URL %s from any source." % u)
+
+        ud.localpath = localpath
+        if os.path.exists(ud.md5):
+            # Touch the md5 file to show active use of the download
+            try:
                os.utime(ud.md5, None)
-                continue
-            # RP - is olddir needed?
-            # olddir = os.path.abspath(os.getcwd())
-            m.go(u, ud	, d)
-            # os.chdir(olddir)
-            if ud.localfile and not m.forcefetch(u, ud, d):
-                Fetch.write_md5sum(u, ud, d)
+            except:
+                # Errors aren't fatal here
+                pass
+        else:
+            Fetch.write_md5sum(u, ud, d)
+
+        bb.utils.unlockfile(lf)
+
+def checkstatus(d):
+    """
+    Check all urls exist upstream
+    init must have previously been called
+    """
+    urldata = init([], d, True)
+
+    for u in urldata:
+        ud = urldata[u]
+        m = ud.method
+        bb.msg.debug(1, bb.msg.domain.Fetcher, "Testing URL %s" % u)
+        # First try checking uri, u, from PREMIRRORS
+        mirrors = mirror_from_string(bb.data.getVar('PREMIRRORS', d, True))
+        ret = try_mirrors(d, u, mirrors, True)
+        if not ret:
+            # Next try checking from the original uri, u
+            try:
+                ret = m.checkstatus(u, ud, d)
+            except:
+                # Finally, try checking uri, u, from MIRRORS
+                mirrors = mirror_from_string(bb.data.getVar('MIRRORS', d, True))
+                ret = try_mirrors (d, u, mirrors, True)
+
+        if not ret:
+            raise FetchError("URL %s doesn't work" % u)

 def localpaths(d):
-    """Return a list of the local filenames, assuming successful fetch"""
+    """
+    Return a list of the local filenames, assuming successful fetch
+    """
    local = []
-    fn = bb.data.getVar('FILE', d, 1)
-    for m in methods:
-        for u in m.urls:
-            local.append(urldata[fn][u].localpath)
+    urldata = init([], d, True)
+
+    for u in urldata:
+        ud = urldata[u]
+        local.append(ud.localpath)
+
    return local

-def localpath(url, d):
-    ud = initdata(url, d)
-    if ud.method:
-        return ud.localpath
+srcrev_internal_call = False
+
+def get_srcrev(d):
+    """
+    Return the version string for the current package
+    (usually to be used as PV)
+    Most packages usually only have one SCM so we just pass on the call.
+    In the multi SCM case, we build a value based on SRCREV_FORMAT which must
+    have been set.
+    """
+
+    #
+    # Ugly code alert. localpath in the fetchers will try to evaluate SRCREV which
+    # could translate into a call to here. If it does, we need to catch this
+    # and provide some way so it knows get_srcrev is active instead of being
+    # some number etc. hence the srcrev_internal_call tracking and the magic
+    # "SRCREVINACTION" return value.
+    #
+    # Neater solutions welcome!
+    #
+    if bb.fetch.srcrev_internal_call:
+        return "SRCREVINACTION"
+
+    scms = []
+
+    # Only call setup_localpath on URIs which suppports_srcrev()
+    urldata = init(bb.data.getVar('SRC_URI', d, 1).split(), d, False)
+    for u in urldata:
+        ud = urldata[u]
+        if ud.method.suppports_srcrev():
+            if not ud.setup:
+                ud.setup_localpath(d)
+            scms.append(u)
+
+    if len(scms) == 0:
+        bb.msg.error(bb.msg.domain.Fetcher, "SRCREV was used yet no valid SCM was found in SRC_URI")
+        raise ParameterError
+
+    if bb.data.getVar('BB_SRCREV_POLICY', d, True) != "cache":
+        bb.data.setVar('__BB_DONT_CACHE', '1', d)
+
+    if len(scms) == 1:
+        return urldata[scms[0]].method.sortable_revision(scms[0], urldata[scms[0]], d)
+
+    #
+    # Mutiple SCMs are in SRC_URI so we resort to SRCREV_FORMAT
+    #
+    format = bb.data.getVar('SRCREV_FORMAT', d, 1)
+    if not format:
+        bb.msg.error(bb.msg.domain.Fetcher, "The SRCREV_FORMAT variable must be set when multiple SCMs are used.")
+        raise ParameterError
+
+    for scm in scms:
+        if 'name' in urldata[scm].parm:
+            name = urldata[scm].parm["name"]
+            rev = urldata[scm].method.sortable_revision(scm, urldata[scm], d)
+            format = format.replace(name, rev)
+
+    return format
+
+def localpath(url, d, cache = True):
+    """
+    Called from the parser with cache=False since the cache isn't ready
+    at this point. Also called from classed in OE e.g. patch.bbclass
+    """
+    ud = init([url], d)
+    if ud[url].method:
+        return ud[url].localpath
    return url

+def runfetchcmd(cmd, d, quiet = False):
+    """
+    Run cmd returning the command output
+    Raise an error if interrupted or cmd fails
+    Optionally echo command output to stdout
+    """
+
+    # Need to export PATH as binary could be in metadata paths
+    # rather than host provided
+    # Also include some other variables.
+    # FIXME: Should really include all export varaiables?
+    exportvars = ['PATH', 'GIT_PROXY_COMMAND', 'GIT_PROXY_HOST',
+                  'GIT_PROXY_PORT', 'GIT_CONFIG', 'http_proxy', 'ftp_proxy',
+                  'https_proxy', 'no_proxy', 'ALL_PROXY', 'all_proxy',
+                  'SSH_AUTH_SOCK', 'SSH_AGENT_PID', 'HOME']
+
+    for var in exportvars:
+        val = data.getVar(var, d, True)
+        if val:
+            cmd = 'export ' + var + '=\"%s\"; %s' % (val, cmd)
+
+    bb.msg.debug(1, bb.msg.domain.Fetcher, "Running %s" % cmd)
+
+    # redirect stderr to stdout
+    stdout_handle = os.popen(cmd + " 2>&1", "r")
+    output = ""
+
+    while True:
+        line = stdout_handle.readline()
+        if not line:
+            break
+        if not quiet:
+            print(line, end=' ')
+        output += line
+
+    status = stdout_handle.close() or 0
+    signal = status >> 8
+    exitstatus = status & 0xff
+
+    if signal:
+        raise FetchError("Fetch command %s failed with signal %s, output:\n%s" % (cmd, signal, output))
+    elif status != 0:
+        raise FetchError("Fetch command %s failed with exit code %s, output:\n%s" % (cmd, status, output))
+
+    return output
+
+def try_mirrors(d, uri, mirrors, check = False, force = False):
+    """
+    Try to use a mirrored version of the sources.
+    This method will be automatically called before the fetchers go.
+
+    d Is a bb.data instance
+    uri is the original uri we're trying to download
+    mirrors is the list of mirrors we're going to try
+    """
+    fpath = os.path.join(data.getVar("DL_DIR", d, 1), os.path.basename(uri))
+    if not check and os.access(fpath, os.R_OK) and not force:
+        bb.msg.debug(1, bb.msg.domain.Fetcher, "%s already exists, skipping checkout." % fpath)
+        return fpath
+
+    ld = d.createCopy()
+    for (find, replace) in mirrors:
+        newuri = uri_replace(uri, find, replace, ld)
+        if newuri != uri:
+            try:
+                ud = FetchData(newuri, ld)
+            except bb.fetch.NoMethodError:
+                bb.msg.debug(1, bb.msg.domain.Fetcher, "No method for %s" % uri)
+                continue
+
+            ud.setup_localpath(ld)
+
+            try:
+                if check:
+                    ud.method.checkstatus(newuri, ud, ld)
+                else:
+                    ud.method.go(newuri, ud, ld)
+                return ud.localpath
+            except (bb.fetch.MissingParameterError,
+                    bb.fetch.FetchError,
+                    bb.fetch.MD5SumError):
+                import sys
+                (type, value, traceback) = sys.exc_info()
+                bb.msg.debug(2, bb.msg.domain.Fetcher, "Mirror fetch failure: %s" % value)
+                removefile(ud.localpath)
+                continue
+    return None
+
+
 class FetchData(object):
-    """Class for fetcher variable store"""
-    def __init__(self):
+    """
+    A class which represents the fetcher state for a given URI.
+    """
+    def __init__(self, url, d):
        self.localfile = ""
+        (self.type, self.host, self.path, self.user, self.pswd, self.parm) = decodeurl(data.expand(url, d))
+        self.date = Fetch.getSRCDate(self, d)
+        self.url = url
+        if not self.user and "user" in self.parm:
+            self.user = self.parm["user"]
+        if not self.pswd and "pswd" in self.parm:
+            self.pswd = self.parm["pswd"]
+        self.setup = False
+        for m in methods:
+            if m.supports(url, self, d):
+                self.method = m
+                return
+        raise NoMethodError("Missing implementation for url %s" % url)
+
+    def setup_localpath(self, d):
+        self.setup = True
+        if "localpath" in self.parm:
+            # if user sets localpath for file, use it instead.
+            self.localpath = self.parm["localpath"]
+            self.basename = os.path.basename(self.localpath)
+        else:
+            premirrors = bb.data.getVar('PREMIRRORS', d, True)
+            local = ""
+            if premirrors and self.url:
+                aurl = self.url.split(";")[0]
+                mirrors = mirror_from_string(premirrors)
+                for (find, replace) in mirrors:
+                    if replace.startswith("file://"):
+                        path = aurl.split("://")[1]
+                        path = path.split(";")[0]
+                        local = replace.split("://")[1] + os.path.basename(path)
+                        if local == aurl or not os.path.exists(local) or os.path.isdir(local):
+                            local = ""
+                self.localpath = local
+            if not local:
+                try:
+                    bb.fetch.srcrev_internal_call = True
+                    self.localpath = self.method.localpath(self.url, self, d)
+                finally:
+                    bb.fetch.srcrev_internal_call = False
+                # We have to clear data's internal caches since the cached value of SRCREV is now wrong.
+                # Horrible...
+                bb.data.delVar("ISHOULDNEVEREXIST", d)
+
+        if self.localpath is not None:
+            # Note: These files should always be in DL_DIR whereas localpath may not be.
+            basepath = bb.data.expand("${DL_DIR}/%s" % os.path.basename(self.localpath), d)
+            self.md5 = basepath + '.md5'
+            self.lockfile = basepath + '.lock'


 class Fetch(object):
@@ -163,7 +555,7 @@ class Fetch(object):
    def localpath(self, url, urldata, d):
        """
        Return the local filename of a given url assuming a successful fetch.
-        Can also setup variables in urldata for use in go (saving code duplication 
+        Can also setup variables in urldata for use in go (saving code duplication
        and duplicate code execution)
        """
        return url
@@ -182,6 +574,12 @@ class Fetch(object):
        """
        return False

+    def suppports_srcrev(self):
+        """
+        The fetcher supports auto source revisions (SRCREV)
+        """
+        return False
+
    def go(self, url, urldata, d):
        """
        Fetch urls
@@ -189,6 +587,25 @@ class Fetch(object):
        """
        raise NoMethodError("Missing implementation for url")

+    def try_premirror(self, url, urldata, d):
+        """
+        Should premirrors be used?
+        """
+        if urldata.method.forcefetch(url, urldata, d):
+            return True
+        elif os.path.exists(urldata.md5) and os.path.exists(urldata.localfile):
+            return False
+        else:
+            return True
+
+    def checkstatus(self, url, urldata, d):
+        """
+        Check the status of a URL
+        Assumes localpath was called first
+        """
+        bb.msg.note(1, bb.msg.domain.Fetcher, "URL %s could not be checked for status since no method exists." % url)
+        return True
+
    def getSRCDate(urldata, d):
        """
        Return the SRC Date for the component
@@ -201,42 +618,61 @@ class Fetch(object):
        pn = data.getVar("PN", d, 1)

        if pn:
-            return data.getVar("SRCDATE_%s" % pn, d, 1) or data.getVar("CVSDATE_%s" % pn, d, 1) or data.getVar("DATE", d, 1)
+            return data.getVar("SRCDATE_%s" % pn, d, 1) or data.getVar("CVSDATE_%s" % pn, d, 1) or data.getVar("SRCDATE", d, 1) or data.getVar("CVSDATE", d, 1) or data.getVar("DATE", d, 1)

        return data.getVar("SRCDATE", d, 1) or data.getVar("CVSDATE", d, 1) or data.getVar("DATE", d, 1)
    getSRCDate = staticmethod(getSRCDate)

-    def try_mirror(d, tarfn):
+    def srcrev_internal_helper(ud, d):
+        """
+        Return:
+            a) a source revision if specified
+            b) True if auto srcrev is in action
+            c) False otherwise
        """
-        Try to use a mirrored version of the sources. We do this
-        to avoid massive loads on foreign cvs and svn servers.
-        This method will be used by the different fetcher
-        implementations.

-        d Is a bb.data instance
-        tarfn is the name of the tarball
-        """
-        tarpath = os.path.join(data.getVar("DL_DIR", d, 1), tarfn)
-        if os.access(tarpath, os.R_OK):
-            bb.msg.debug(1, bb.msg.domain.Fetcher, "%s already exists, skipping checkout." % tarfn)
+        if 'rev' in ud.parm:
+            return ud.parm['rev']
+
+        if 'tag' in ud.parm:
+            return ud.parm['tag']
+
+        rev = None
+        if 'name' in ud.parm:
+            pn = data.getVar("PN", d, 1)
+            rev = data.getVar("SRCREV_%s_pn-%s" % (ud.parm['name'], pn), d, 1)
+            if not rev:
+                rev = data.getVar("SRCREV_pn-%s_%s" % (pn, ud.parm['name']), d, 1)
+            if not rev:
+                rev = data.getVar("SRCREV_%s" % (ud.parm['name']), d, 1)           
+        if not rev:
+            rev = data.getVar("SRCREV", d, 1)
+        if rev == "INVALID":
+            raise InvalidSRCREV("Please set SRCREV to a valid value")
+        if not rev:
+            return False
+        if rev is "SRCREVINACTION":
            return True
+        return rev

-        pn = data.getVar('PN', d, True)
-        src_tarball_stash = None
-        if pn:
-            src_tarball_stash = (data.getVar('SRC_TARBALL_STASH_%s' % pn, d, True) or data.getVar('CVS_TARBALL_STASH_%s' % pn, d, True) or data.getVar('SRC_TARBALL_STASH', d, True) or data.getVar('CVS_TARBALL_STASH', d, True) or "").split()
+    srcrev_internal_helper = staticmethod(srcrev_internal_helper)

-        for stash in src_tarball_stash:
-            fetchcmd = data.getVar("FETCHCOMMAND_mirror", d, True) or data.getVar("FETCHCOMMAND_wget", d, True)
-            uri = stash + tarfn
-            bb.msg.note(1, bb.msg.domain.Fetcher, "fetch " + uri)
-            fetchcmd = fetchcmd.replace("${URI}", uri)
-            ret = os.system(fetchcmd)
-            if ret == 0:
-                bb.msg.note(1, bb.msg.domain.Fetcher, "Fetched %s from tarball stash, skipping checkout" % tarfn)
-                return True
-        return False
-    try_mirror = staticmethod(try_mirror)
+    def localcount_internal_helper(ud, d):
+        """
+        Return:
+            a) a locked localcount if specified
+            b) None otherwise
+        """
+
+        localcount = None
+        if 'name' in ud.parm:
+            pn = data.getVar("PN", d, 1)
+            localcount = data.getVar("LOCALCOUNT_" + ud.parm['name'], d, 1)
+        if not localcount:
+            localcount = data.getVar("LOCALCOUNT", d, 1)
+        return localcount
+
+    localcount_internal_helper = staticmethod(localcount_internal_helper)

    def verify_md5sum(ud, got_sum):
        """
@@ -252,14 +688,7 @@ class Fetch(object):
    verify_md5sum = staticmethod(verify_md5sum)

    def write_md5sum(url, ud, d):
-        if bb.which(data.getVar('PATH', d), 'md5sum'):
-            try:
-                md5pipe = os.popen('md5sum ' + ud.localpath)
-                md5data = (md5pipe.readline().split() or [ "" ])[0]
-                md5pipe.close()
-            except OSError:
-                md5data = ""
-
+        md5data = bb.utils.md5_file(ud.localpath)
        # verify the md5sum
        if not Fetch.verify_md5sum(ud, md5data):
            raise MD5SumError(url)
@@ -269,20 +698,87 @@ class Fetch(object):
        md5out.close()
    write_md5sum = staticmethod(write_md5sum)

-import cvs
-import git
-import local
-import svn
-import wget
-import svk
-import ssh
-import perforce
+    def latest_revision(self, url, ud, d):
+        """
+        Look in the cache for the latest revision, if not present ask the SCM.
+        """
+        if not hasattr(self, "_latest_revision"):
+            raise ParameterError
+
+        pd = persist_data.PersistData(d, persistent_database_connection)
+        key = self.generate_revision_key(url, ud, d)
+        rev = pd.getValue("BB_URI_HEADREVS", key)
+        if rev != None:
+            return str(rev)
+
+        rev = self._latest_revision(url, ud, d)
+        pd.setValue("BB_URI_HEADREVS", key, rev)
+        return rev
+
+    def sortable_revision(self, url, ud, d):
+        """
+
+        """
+        if hasattr(self, "_sortable_revision"):
+            return self._sortable_revision(url, ud, d)
+
+        pd = persist_data.PersistData(d, persistent_database_connection)
+        key = self.generate_revision_key(url, ud, d)
+
+        latest_rev = self._build_revision(url, ud, d)
+        last_rev = pd.getValue("BB_URI_LOCALCOUNT", key + "_rev")
+        uselocalcount = bb.data.getVar("BB_LOCALCOUNT_OVERRIDE", d, True) or False
+        count = None
+        if uselocalcount:
+            count = Fetch.localcount_internal_helper(ud, d)
+        if count is None:
+            count = pd.getValue("BB_URI_LOCALCOUNT", key + "_count")
+
+        if last_rev == latest_rev:
+            return str(count + "+" + latest_rev)
+
+        buildindex_provided = hasattr(self, "_sortable_buildindex")
+        if buildindex_provided:
+            count = self._sortable_buildindex(url, ud, d, latest_rev)
+
+        if count is None:
+            count = "0"
+        elif uselocalcount or buildindex_provided:
+            count = str(count)
+        else:
+            count = str(int(count) + 1)
+
+        pd.setValue("BB_URI_LOCALCOUNT", key + "_rev", latest_rev)
+        pd.setValue("BB_URI_LOCALCOUNT", key + "_count", count)
+
+        return str(count + "+" + latest_rev)
+
+    def generate_revision_key(self, url, ud, d):
+        key = self._revision_key(url, ud, d)
+        return "%s-%s" % (key, bb.data.getVar("PN", d, True) or "")
+
+from . import cvs
+from . import git
+from . import local
+from . import svn
+from . import wget
+from . import svk
+from . import ssh
+from . import perforce
+from . import bzr
+from . import hg
+from . import osc
+from . import repo

-methods.append(cvs.Cvs())
-methods.append(git.Git())
 methods.append(local.Local())
-methods.append(svn.Svn())
 methods.append(wget.Wget())
+methods.append(svn.Svn())
+methods.append(git.Git())
+methods.append(cvs.Cvs())
 methods.append(svk.Svk())
 methods.append(ssh.SSH())
 methods.append(perforce.Perforce())
+methods.append(bzr.Bzr())
+methods.append(hg.Hg())
+methods.append(osc.Osc())
+methods.append(repo.Repo())
--- a/bitbake/lib/bb/fetch/bzr.py
+++ b/bitbake/lib/bb/fetch/bzr.py
@@ -0,0 +1,147 @@
+"""
+BitBake 'Fetch' implementation for bzr.
+
+"""
+
+# Copyright (C) 2007 Ross Burton
+# Copyright (C) 2007 Richard Purdie
+#
+#   Classes for obtaining upstream sources for the
+#   BitBake build tools.
+#   Copyright (C) 2003, 2004  Chris Larson
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License version 2 as
+# published by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License along
+# with this program; if not, write to the Free Software Foundation, Inc.,
+# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+
+import os
+import sys
+import bb
+from bb import data
+from bb.fetch import Fetch
+from bb.fetch import FetchError
+from bb.fetch import runfetchcmd
+
+class Bzr(Fetch):
+    def supports(self, url, ud, d):
+        return ud.type in ['bzr']
+
+    def localpath (self, url, ud, d):
+
+        # Create paths to bzr checkouts
+        relpath = ud.path
+        if relpath.startswith('/'):
+            # Remove leading slash as os.path.join can't cope
+            relpath = relpath[1:]
+        ud.pkgdir = os.path.join(data.expand('${BZRDIR}', d), ud.host, relpath)
+
+        revision = Fetch.srcrev_internal_helper(ud, d)
+        if revision is True:
+            ud.revision = self.latest_revision(url, ud, d)
+        elif revision:
+            ud.revision = revision
+
+        if not ud.revision:
+            ud.revision = self.latest_revision(url, ud, d)
+
+        ud.localfile = data.expand('bzr_%s_%s_%s.tar.gz' % (ud.host, ud.path.replace('/', '.'), ud.revision), d)
+
+        return os.path.join(data.getVar("DL_DIR", d, True), ud.localfile)
+
+    def _buildbzrcommand(self, ud, d, command):
+        """
+        Build up an bzr commandline based on ud
+        command is "fetch", "update", "revno"
+        """
+
+        basecmd = data.expand('${FETCHCMD_bzr}', d)
+
+        proto = "http"
+        if "proto" in ud.parm:
+            proto = ud.parm["proto"]
+
+        bzrroot = ud.host + ud.path
+
+        options = []
+
+        if command is "revno":
+            bzrcmd = "%s revno %s %s://%s" % (basecmd, " ".join(options), proto, bzrroot)
+        else:
+            if ud.revision:
+                options.append("-r %s" % ud.revision)
+
+            if command is "fetch":
+                bzrcmd = "%s co %s %s://%s" % (basecmd, " ".join(options), proto, bzrroot)
+            elif command is "update":
+                bzrcmd = "%s pull %s --overwrite" % (basecmd, " ".join(options))
+            else:
+                raise FetchError("Invalid bzr command %s" % command)
+
+        return bzrcmd
+
+    def go(self, loc, ud, d):
+        """Fetch url"""
+
+        if os.access(os.path.join(ud.pkgdir, os.path.basename(ud.pkgdir), '.bzr'), os.R_OK):
+            bzrcmd = self._buildbzrcommand(ud, d, "update")
+            bb.msg.debug(1, bb.msg.domain.Fetcher, "BZR Update %s" % loc)
+            os.chdir(os.path.join (ud.pkgdir, os.path.basename(ud.path)))
+            runfetchcmd(bzrcmd, d)
+        else:
+            os.system("rm -rf %s" % os.path.join(ud.pkgdir, os.path.basename(ud.pkgdir)))
+            bzrcmd = self._buildbzrcommand(ud, d, "fetch")
+            bb.msg.debug(1, bb.msg.domain.Fetcher, "BZR Checkout %s" % loc)
+            bb.mkdirhier(ud.pkgdir)
+            os.chdir(ud.pkgdir)
+            bb.msg.debug(1, bb.msg.domain.Fetcher, "Running %s" % bzrcmd)
+            runfetchcmd(bzrcmd, d)
+
+        os.chdir(ud.pkgdir)
+        # tar them up to a defined filename
+        try:
+            runfetchcmd("tar -czf %s %s" % (ud.localpath, os.path.basename(ud.pkgdir)), d)
+        except:
+            t, v, tb = sys.exc_info()
+            try:
+                os.unlink(ud.localpath)
+            except OSError:
+                pass
+            raise t, v, tb
+
+    def suppports_srcrev(self):
+        return True
+
+    def _revision_key(self, url, ud, d):
+        """
+        Return a unique key for the url
+        """
+        return "bzr:" + ud.pkgdir
+
+    def _latest_revision(self, url, ud, d):
+        """
+        Return the latest upstream revision number
+        """
+        bb.msg.debug(2, bb.msg.domain.Fetcher, "BZR fetcher hitting network for %s" % url)
+
+        output = runfetchcmd(self._buildbzrcommand(ud, d, "revno"), d, True)
+
+        return output.strip()
+
+    def _sortable_revision(self, url, ud, d):
+        """
+        Return a sortable revision number which in our case is the revision number
+        """
+
+        return self._build_revision(url, ud, d)
+
+    def _build_revision(self, url, ud, d):
+        return ud.revision
--- a/bitbake/lib/bb/fetch/cvs.py
+++ b/bitbake/lib/bb/fetch/cvs.py
@@ -26,7 +26,7 @@ BitBake build tools.
 #Based on functions from the base bb module, Copyright 2003 Holger Schurig
 #

-import os, re
+import os
 import bb
 from   bb import data
 from   bb.fetch import Fetch
@@ -41,7 +41,7 @@ class Cvs(Fetch):
        """
        Check to see if a given url can be fetched with cvs.
        """
-        return ud.type in ['cvs', 'pserver']
+        return ud.type in ['cvs']

    def localpath(self, url, ud, d):
        if not "module" in ud.parm:
@@ -58,7 +58,15 @@ class Cvs(Fetch):
        elif ud.tag:
            ud.date = ""

-        ud.localfile = data.expand('%s_%s_%s_%s.tar.gz' % (ud.module.replace('/', '.'), ud.host, ud.tag, ud.date), d)
+        norecurse = ''
+        if 'norecurse' in ud.parm:
+            norecurse = '_norecurse'
+
+        fullpath = ''
+        if 'fullpath' in ud.parm:
+            fullpath = '_fullpath'
+
+        ud.localfile = data.expand('%s_%s_%s_%s%s%s.tar.gz' % (ud.module.replace('/', '.'), ud.host, ud.tag, ud.date, norecurse, fullpath), d)

        return os.path.join(data.getVar("DL_DIR", d, True), ud.localfile)

@@ -69,11 +77,6 @@ class Cvs(Fetch):

    def go(self, loc, ud, d):

-        # try to use the tarball stash
-        if not self.forcefetch(loc, ud, d) and Fetch.try_mirror(d, ud.localfile):
-            bb.msg.debug(1, bb.msg.domain.Fetcher, "%s already exists or was mirrored, skipping cvs checkout." % ud.localpath)
-            return
-
        method = "pserver"
        if "method" in ud.parm:
            method = ud.parm["method"]
@@ -94,14 +97,27 @@ class Cvs(Fetch):
        if method == "dir":
            cvsroot = ud.path
        else:
-            cvsroot = ":" + method + ":" + ud.user
+            cvsroot = ":" + method
+            cvsproxyhost = data.getVar('CVS_PROXY_HOST', d, True)
+            if cvsproxyhost:
+                cvsroot += ";proxy=" + cvsproxyhost
+            cvsproxyport = data.getVar('CVS_PROXY_PORT', d, True)
+            if cvsproxyport:
+                cvsroot += ";proxyport=" + cvsproxyport
+            cvsroot += ":" + ud.user
            if ud.pswd:
                cvsroot += ":" + ud.pswd
            cvsroot += "@" + ud.host + ":" + cvs_port + ud.path

        options = []
+        if 'norecurse' in ud.parm:
+            options.append("-l")
        if ud.date:
-            options.append("-D %s" % ud.date)
+            # treat YYYYMMDDHHMM specially for CVS
+            if len(ud.date) == 12:
+                options.append("-D \"%s %s:%s UTC\"" % (ud.date[0:8], ud.date[8:10], ud.date[10:12]))
+            else:
+                options.append("-D \"%s UTC\"" % ud.date)
        if ud.tag:
            options.append("-r %s" % ud.tag)

@@ -123,8 +139,8 @@ class Cvs(Fetch):
        bb.msg.debug(2, bb.msg.domain.Fetcher, "Fetch: checking for module directory")
        pkg = data.expand('${PN}', d)
        pkgdir = os.path.join(data.expand('${CVSDIR}', localdata), pkg)
-        moddir = os.path.join(pkgdir,localdir)
-        if os.access(os.path.join(moddir,'CVS'), os.R_OK):
+        moddir = os.path.join(pkgdir, localdir)
+        if os.access(os.path.join(moddir, 'CVS'), os.R_OK):
            bb.msg.note(1, bb.msg.domain.Fetcher, "Update " + loc)
            # update sources there
            os.chdir(moddir)
@@ -141,13 +157,18 @@ class Cvs(Fetch):
            try:
                os.rmdir(moddir)
            except OSError:
-                 pass
+                pass
            raise FetchError(ud.module)

-        os.chdir(moddir)
-        os.chdir('..')
        # tar them up to a defined filename
-        myret = os.system("tar -czf %s %s" % (ud.localpath, os.path.basename(moddir)))
+        if 'fullpath' in ud.parm:
+            os.chdir(pkgdir)
+            myret = os.system("tar -czf %s %s" % (ud.localpath, localdir))
+        else:
+            os.chdir(moddir)
+            os.chdir('..')
+            myret = os.system("tar -czf %s %s" % (ud.localpath, os.path.basename(moddir)))
+
        if myret != 0:
            try:
                os.unlink(ud.localpath)
--- a/bitbake/lib/bb/fetch/git.py
+++ b/bitbake/lib/bb/fetch/git.py
@@ -20,36 +20,20 @@ BitBake 'Fetch' git implementation
 # with this program; if not, write to the Free Software Foundation, Inc.,
 # 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.

-import os, re
+import os
 import bb
 from   bb    import data
 from   bb.fetch import Fetch
-from   bb.fetch import FetchError
-
-def prunedir(topdir):
-    # Delete everything reachable from the directory named in 'topdir'.
-    # CAUTION:  This is dangerous!
-    for root, dirs, files in os.walk(topdir, topdown=False):
-        for name in files:
-            os.remove(os.path.join(root, name))
-        for name in dirs:
-            os.rmdir(os.path.join(root, name))
-
-def rungitcmd(cmd,d):
-
-    bb.msg.debug(1, bb.msg.domain.Fetcher, "Running %s" % cmd)
-
-    # Need to export PATH as git is likely to be in metadata paths 
-    # rather than host provided
-    pathcmd = 'export PATH=%s; %s' % (data.expand('${PATH}', d), cmd)
-
-    myret = os.system(pathcmd)
-
-    if myret != 0:
-        raise FetchError("Git: %s failed" % pathcmd)
+from   bb.fetch import runfetchcmd

 class Git(Fetch):
    """Class to fetch a module or modules from git repositories"""
+    def init(self, d):
+        #
+        # Only enable _sortable revision if the key is set
+        #
+        if bb.data.getVar("BB_GIT_CLONE_FOR_SRCREV", d, True):
+            self._sortable_buildindex = self._sortable_buildindex_disabled
    def supports(self, url, ud, d):
        """
        Check to see if a given url can be fetched with git.
@@ -58,70 +42,213 @@ class Git(Fetch):

    def localpath(self, url, ud, d):

-        ud.proto = "rsync"
        if 'protocol' in ud.parm:
            ud.proto = ud.parm['protocol']
+        elif not ud.host:
+            ud.proto = 'file'
+        else:
+            ud.proto = "rsync"

-        ud.tag = "master"
-        if 'tag' in ud.parm:
-            ud.tag = ud.parm['tag']
+        ud.branch = ud.parm.get("branch", "master")

-        ud.localfile = data.expand('git_%s%s_%s.tar.gz' % (ud.host, ud.path.replace('/', '.'), ud.tag), d)
+        gitsrcname = '%s%s' % (ud.host, ud.path.replace('/', '.'))
+        ud.mirrortarball = 'git_%s.tar.gz' % (gitsrcname)
+        ud.clonedir = os.path.join(data.expand('${GITDIR}', d), gitsrcname)
+
+        tag = Fetch.srcrev_internal_helper(ud, d)
+        if tag is True:
+            ud.tag = self.latest_revision(url, ud, d)
+        elif tag:
+            ud.tag = tag
+
+        if not ud.tag or ud.tag == "master":
+            ud.tag = self.latest_revision(url, ud, d)
+
+        subdir = ud.parm.get("subpath", "")
+        if subdir != "":
+            if subdir.endswith("/"):
+                subdir = subdir[:-1]
+            subdirpath = os.path.join(ud.path, subdir);
+        else:
+            subdirpath = ud.path;
+
+        if 'fullclone' in ud.parm:
+            ud.localfile = ud.mirrortarball
+        else:
+            ud.localfile = data.expand('git_%s%s_%s.tar.gz' % (ud.host, subdirpath.replace('/', '.'), ud.tag), d)
+
+        ud.basecmd = data.getVar("FETCHCMD_git", d, True) or "git"
+
+        if 'noclone' in ud.parm:
+            ud.localfile = None
+            return None

        return os.path.join(data.getVar("DL_DIR", d, True), ud.localfile)

    def forcefetch(self, url, ud, d):
-        # tag=="master" must always update
-        if (ud.tag == "master"):
+        if 'fullclone' in ud.parm:
+            return True
+        if 'noclone' in ud.parm:
+            return False
+        if os.path.exists(ud.localpath):
+            return False
+        if not self._contains_ref(ud.tag, d):
            return True
        return False

+    def try_premirror(self, u, ud, d):
+        if 'noclone' in ud.parm:
+            return False
+        if os.path.exists(ud.clonedir):
+            return False
+        if os.path.exists(ud.localpath):
+            return False
+
+        return True
+
    def go(self, loc, ud, d):
        """Fetch url"""

-        if not self.forcefetch(loc, ud, d) and Fetch.try_mirror(d, ud.localfile):
-            bb.msg.debug(1, bb.msg.domain.Fetcher, "%s already exists (or was stashed). Skipping git checkout." % ud.localpath)
-            return
+        if ud.user:
+            username = ud.user + '@'
+        else:
+            username = ""

-        gitsrcname = '%s%s' % (ud.host, ud.path.replace('/', '.'))
-
-        repofilename = 'git_%s.tar.gz' % (gitsrcname)
-        repofile = os.path.join(data.getVar("DL_DIR", d, 1), repofilename)
-        repodir = os.path.join(data.expand('${GITDIR}', d), gitsrcname)
+        repofile = os.path.join(data.getVar("DL_DIR", d, 1), ud.mirrortarball)

        coname = '%s' % (ud.tag)
-        codir = os.path.join(repodir, coname)
+        codir = os.path.join(ud.clonedir, coname)

-        if not os.path.exists(repodir):
-            if Fetch.try_mirror(d, repofilename):    
-                bb.mkdirhier(repodir)
-                os.chdir(repodir)
-                rungitcmd("tar -xzf %s" % (repofile),d)
+        # If we have no existing clone and no mirror tarball, try and obtain one
+        if not os.path.exists(ud.clonedir) and not os.path.exists(repofile):
+            try:
+                Fetch.try_mirrors(ud.mirrortarball)
+            except:
+                pass
+
+        # If the checkout doesn't exist and the mirror tarball does, extract it
+        if not os.path.exists(ud.clonedir) and os.path.exists(repofile):
+            bb.mkdirhier(ud.clonedir)
+            os.chdir(ud.clonedir)
+            runfetchcmd("tar -xzf %s" % (repofile), d)
+
+        # If the repo still doesn't exist, fallback to cloning it
+        if not os.path.exists(ud.clonedir):
+            runfetchcmd("%s clone -n %s://%s%s%s %s" % (ud.basecmd, ud.proto, username, ud.host, ud.path, ud.clonedir), d)
+
+        os.chdir(ud.clonedir)
+        # Update the checkout if needed
+        if not self._contains_ref(ud.tag, d) or 'fullclone' in ud.parm:
+            # Remove all but the .git directory
+            runfetchcmd("rm * -Rf", d)
+            if 'fullclone' in ud.parm:
+                runfetchcmd("%s fetch --all" % (ud.basecmd), d)
            else:
-                rungitcmd("git clone -n %s://%s%s %s" % (ud.proto, ud.host, ud.path, repodir),d)
+                runfetchcmd("%s fetch %s://%s%s%s %s" % (ud.basecmd, ud.proto, username, ud.host, ud.path, ud.branch), d)
+            runfetchcmd("%s fetch --tags %s://%s%s%s" % (ud.basecmd, ud.proto, username, ud.host, ud.path), d)
+            runfetchcmd("%s prune-packed" % ud.basecmd, d)
+            runfetchcmd("%s pack-redundant --all | xargs -r rm" % ud.basecmd, d)

-        os.chdir(repodir)
-        rungitcmd("git pull %s://%s%s" % (ud.proto, ud.host, ud.path),d)
-        rungitcmd("git pull --tags %s://%s%s" % (ud.proto, ud.host, ud.path),d)
-        rungitcmd("git prune-packed", d)
-        rungitcmd("git pack-redundant --all | xargs -r rm", d)
-        # Remove all but the .git directory
-        rungitcmd("rm * -Rf", d)
-        # old method of downloading tags
-        #rungitcmd("rsync -a --verbose --stats --progress rsync://%s%s/ %s" % (ud.host, ud.path, os.path.join(repodir, ".git", "")),d)
+        # Generate a mirror tarball if needed
+        os.chdir(ud.clonedir)
+        mirror_tarballs = data.getVar("BB_GENERATE_MIRROR_TARBALLS", d, True)
+        if mirror_tarballs != "0" or 'fullclone' in ud.parm:
+            bb.msg.note(1, bb.msg.domain.Fetcher, "Creating tarball of git repository")
+            runfetchcmd("tar -czf %s %s" % (repofile, os.path.join(".", ".git", "*") ), d)

-        os.chdir(repodir)
-        bb.msg.note(1, bb.msg.domain.Fetcher, "Creating tarball of git repository")
-        rungitcmd("tar -czf %s %s" % (repofile, os.path.join(".", ".git", "*") ),d)
+        if 'fullclone' in ud.parm:
+            return

        if os.path.exists(codir):
-            prunedir(codir)
+            bb.utils.prunedir(codir)
+
+        subdir = ud.parm.get("subpath", "")
+        if subdir != "":
+            if subdir.endswith("/"):
+                subdirbase = os.path.basename(subdir[:-1])
+            else:
+                subdirbase = os.path.basename(subdir)
+        else:
+            subdirbase = ""
+
+        if subdir != "":
+            readpathspec = ":%s" % (subdir)
+            codir = os.path.join(codir, "git")
+            coprefix = os.path.join(codir, subdirbase, "")
+        else:
+            readpathspec = ""
+            coprefix = os.path.join(codir, "git", "")

        bb.mkdirhier(codir)
-        os.chdir(repodir)
-        rungitcmd("git read-tree %s" % (ud.tag),d)
-        rungitcmd("git checkout-index -q -f --prefix=%s -a" % (os.path.join(codir, "git", "")),d)
+        os.chdir(ud.clonedir)
+        runfetchcmd("%s read-tree %s%s" % (ud.basecmd, ud.tag, readpathspec), d)
+        runfetchcmd("%s checkout-index -q -f --prefix=%s -a" % (ud.basecmd, coprefix), d)

        os.chdir(codir)
        bb.msg.note(1, bb.msg.domain.Fetcher, "Creating tarball of git checkout")
-        rungitcmd("tar -czf %s %s" % (ud.localpath, os.path.join(".", "*") ),d)
+        runfetchcmd("tar -czf %s %s" % (ud.localpath, os.path.join(".", "*") ), d)
+
+        os.chdir(ud.clonedir)
+        bb.utils.prunedir(codir)
+
+    def suppports_srcrev(self):
+        return True
+
+    def _contains_ref(self, tag, d):
+        basecmd = data.getVar("FETCHCMD_git", d, True) or "git"
+        output = runfetchcmd("%s log --pretty=oneline -n 1 %s -- 2> /dev/null | wc -l" % (basecmd, tag), d, quiet=True)
+        return output.split()[0] != "0"
+
+    def _revision_key(self, url, ud, d):
+        """
+        Return a unique key for the url
+        """
+        return "git:" + ud.host + ud.path.replace('/', '.') + ud.branch
+
+    def _latest_revision(self, url, ud, d):
+        """
+        Compute the HEAD revision for the url
+        """
+        if ud.user:
+            username = ud.user + '@'
+        else:
+            username = ""
+
+        basecmd = data.getVar("FETCHCMD_git", d, True) or "git"
+        cmd = "%s ls-remote %s://%s%s%s %s" % (basecmd, ud.proto, username, ud.host, ud.path, ud.branch)
+        output = runfetchcmd(cmd, d, True)
+        if not output:
+            raise bb.fetch.FetchError("Fetch command %s gave empty output\n" % (cmd))
+        return output.split()[0]
+
+    def _build_revision(self, url, ud, d):
+        return ud.tag
+
+    def _sortable_buildindex_disabled(self, url, ud, d, rev):
+        """
+        Return a suitable buildindex for the revision specified. This is done by counting revisions
+        using "git rev-list" which may or may not work in different circumstances.
+        """
+
+        cwd = os.getcwd()
+
+        # Check if we have the rev already
+
+        if not os.path.exists(ud.clonedir):
+            print("no repo")
+            self.go(None, ud, d)
+            if not os.path.exists(ud.clonedir):
+                bb.msg.error(bb.msg.domain.Fetcher, "GIT repository for %s doesn't exist in %s, cannot get sortable buildnumber, using old value" % (url, ud.clonedir))
+                return None
+
+
+        os.chdir(ud.clonedir)
+        if not self._contains_ref(rev, d):
+            self.go(None, ud, d)
+
+        output = runfetchcmd("%s rev-list %s -- 2> /dev/null | wc -l" % (ud.basecmd, rev), d, quiet=True)
+        os.chdir(cwd)
+
+        buildindex = "%s" % output.split()[0]
+        bb.msg.debug(1, bb.msg.domain.Fetcher, "GIT repository for %s in %s is returning %s revisions in rev-list before %s" % (url, ud.clonedir, buildindex, rev))
+        return buildindex
--- a/bitbake/lib/bb/fetch/hg.py
+++ b/bitbake/lib/bb/fetch/hg.py
@@ -0,0 +1,172 @@
+# ex:ts=4:sw=4:sts=4:et
+# -*- tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*-
+"""
+BitBake 'Fetch' implementation for mercurial DRCS (hg).
+
+"""
+
+# Copyright (C) 2003, 2004  Chris Larson
+# Copyright (C) 2004        Marcin Juszkiewicz
+# Copyright (C) 2007        Robert Schuster
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License version 2 as
+# published by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License along
+# with this program; if not, write to the Free Software Foundation, Inc.,
+# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+#
+# Based on functions from the base bb module, Copyright 2003 Holger Schurig
+
+import os
+import sys
+import bb
+from bb import data
+from bb.fetch import Fetch
+from bb.fetch import FetchError
+from bb.fetch import MissingParameterError
+from bb.fetch import runfetchcmd
+
+class Hg(Fetch):
+    """Class to fetch a from mercurial repositories"""
+    def supports(self, url, ud, d):
+        """
+        Check to see if a given url can be fetched with mercurial.
+        """
+        return ud.type in ['hg']
+
+    def localpath(self, url, ud, d):
+        if not "module" in ud.parm:
+            raise MissingParameterError("hg method needs a 'module' parameter")
+
+        ud.module = ud.parm["module"]
+
+        # Create paths to mercurial checkouts
+        relpath = ud.path
+        if relpath.startswith('/'):
+            # Remove leading slash as os.path.join can't cope
+            relpath = relpath[1:]
+        ud.pkgdir = os.path.join(data.expand('${HGDIR}', d), ud.host, relpath)
+        ud.moddir = os.path.join(ud.pkgdir, ud.module)
+
+        if 'rev' in ud.parm:
+            ud.revision = ud.parm['rev']
+        else:
+            tag = Fetch.srcrev_internal_helper(ud, d)
+            if tag is True:
+                ud.revision = self.latest_revision(url, ud, d)
+            elif tag:
+                ud.revision = tag
+            else:
+                ud.revision = self.latest_revision(url, ud, d)
+
+        ud.localfile = data.expand('%s_%s_%s_%s.tar.gz' % (ud.module.replace('/', '.'), ud.host, ud.path.replace('/', '.'), ud.revision), d)
+
+        return os.path.join(data.getVar("DL_DIR", d, True), ud.localfile)
+
+    def _buildhgcommand(self, ud, d, command):
+        """
+        Build up an hg commandline based on ud
+        command is "fetch", "update", "info"
+        """
+
+        basecmd = data.expand('${FETCHCMD_hg}', d)
+
+        proto = "http"
+        if "proto" in ud.parm:
+            proto = ud.parm["proto"]
+
+        host = ud.host
+        if proto == "file":
+            host = "/"
+            ud.host = "localhost"
+
+        if not ud.user:
+            hgroot = host + ud.path
+        else:
+            hgroot = ud.user + "@" + host + ud.path
+
+        if command is "info":
+            return "%s identify -i %s://%s/%s" % (basecmd, proto, hgroot, ud.module)
+
+        options = [];
+        if ud.revision:
+            options.append("-r %s" % ud.revision)
+
+        if command is "fetch":
+            cmd = "%s clone %s %s://%s/%s %s" % (basecmd, " ".join(options), proto, hgroot, ud.module, ud.module)
+        elif command is "pull":
+            # do not pass options list; limiting pull to rev causes the local
+            # repo not to contain it and immediately following "update" command
+            # will crash
+            cmd = "%s pull" % (basecmd)
+        elif command is "update":
+            cmd = "%s update -C %s" % (basecmd, " ".join(options))
+        else:
+            raise FetchError("Invalid hg command %s" % command)
+
+        return cmd
+
+    def go(self, loc, ud, d):
+        """Fetch url"""
+
+        bb.msg.debug(2, bb.msg.domain.Fetcher, "Fetch: checking for module directory '" + ud.moddir + "'")
+
+        if os.access(os.path.join(ud.moddir, '.hg'), os.R_OK):
+            updatecmd = self._buildhgcommand(ud, d, "pull")
+            bb.msg.note(1, bb.msg.domain.Fetcher, "Update " + loc)
+            # update sources there
+            os.chdir(ud.moddir)
+            bb.msg.debug(1, bb.msg.domain.Fetcher, "Running %s" % updatecmd)
+            runfetchcmd(updatecmd, d)
+
+        else:
+            fetchcmd = self._buildhgcommand(ud, d, "fetch")
+            bb.msg.note(1, bb.msg.domain.Fetcher, "Fetch " + loc)
+            # check out sources there
+            bb.mkdirhier(ud.pkgdir)
+            os.chdir(ud.pkgdir)
+            bb.msg.debug(1, bb.msg.domain.Fetcher, "Running %s" % fetchcmd)
+            runfetchcmd(fetchcmd, d)
+
+        # Even when we clone (fetch), we still need to update as hg's clone
+        # won't checkout the specified revision if its on a branch
+        updatecmd = self._buildhgcommand(ud, d, "update")
+        bb.msg.debug(1, bb.msg.domain.Fetcher, "Running %s" % updatecmd)
+        runfetchcmd(updatecmd, d)
+
+        os.chdir(ud.pkgdir)
+        try:
+            runfetchcmd("tar -czf %s %s" % (ud.localpath, ud.module), d)
+        except:
+            t, v, tb = sys.exc_info()
+            try:
+                os.unlink(ud.localpath)
+            except OSError:
+                pass
+            raise t, v, tb
+
+    def suppports_srcrev(self):
+        return True
+
+    def _latest_revision(self, url, ud, d):
+        """
+        Compute tip revision for the url
+        """
+        output = runfetchcmd(self._buildhgcommand(ud, d, "info"), d)
+        return output.strip()
+
+    def _build_revision(self, url, ud, d):
+        return ud.revision
+
+    def _revision_key(self, url, ud, d):
+        """
+        Return a unique key for the url
+        """
+        return "hg:" + ud.moddir
--- a/bitbake/lib/bb/fetch/local.py
+++ b/bitbake/lib/bb/fetch/local.py
@@ -25,27 +25,30 @@ BitBake build tools.
 #
 # Based on functions from the base bb module, Copyright 2003 Holger Schurig

-import os, re
+import os
 import bb
+import bb.utils
 from   bb import data
 from   bb.fetch import Fetch

 class Local(Fetch):
    def supports(self, url, urldata, d):
        """
-        Check to see if a given url can be fetched with cvs.
+        Check to see if a given url represents a local fetch.
        """
-        return urldata.type in ['file','patch']
+        return urldata.type in ['file']

    def localpath(self, url, urldata, d):
-        """Return the local filename of a given url assuming a successful fetch.
+        """
+        Return the local filename of a given url assuming a successful fetch.
        """
        path = url.split("://")[1]
+        path = path.split(";")[0]
        newpath = path
        if path[0] != "/":
            filespath = data.getVar('FILESPATH', d, 1)
            if filespath:
-                newpath = bb.which(filespath, path)
+                newpath = bb.utils.which(filespath, path)
            if not newpath:
                filesdir = data.getVar('FILESDIR', d, 1)
                if filesdir:
@@ -57,3 +60,14 @@ class Local(Fetch):
        """Fetch urls (no-op for Local method)"""
        # no need to fetch local files, we'll deal with them in place.
        return 1
+
+    def checkstatus(self, url, urldata, d):
+        """
+        Check the status of the url
+        """
+        if urldata.localpath.find("*") != -1:
+            bb.msg.note(1, bb.msg.domain.Fetcher, "URL %s looks like a glob and was therefore not checked." % url)
+            return True
+        if os.path.exists(urldata.localpath):
+            return True
+        return False
--- a/bitbake/lib/bb/fetch/osc.py
+++ b/bitbake/lib/bb/fetch/osc.py
@@ -0,0 +1,150 @@
+# ex:ts=4:sw=4:sts=4:et
+# -*- tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*-
+"""
+Bitbake "Fetch" implementation for osc (Opensuse build service client).
+Based on the svn "Fetch" implementation.
+
+"""
+
+import  os
+import  sys
+import  bb
+from    bb       import data
+from    bb.fetch import Fetch
+from    bb.fetch import FetchError
+from    bb.fetch import MissingParameterError
+from    bb.fetch import runfetchcmd
+
+class Osc(Fetch):
+    """Class to fetch a module or modules from Opensuse build server
+       repositories."""
+
+    def supports(self, url, ud, d):
+        """
+        Check to see if a given url can be fetched with osc.
+        """
+        return ud.type in ['osc']
+
+    def localpath(self, url, ud, d):
+        if not "module" in ud.parm:
+            raise MissingParameterError("osc method needs a 'module' parameter.")
+
+        ud.module = ud.parm["module"]
+
+        # Create paths to osc checkouts
+        relpath = ud.path
+        if relpath.startswith('/'):
+            # Remove leading slash as os.path.join can't cope
+            relpath = relpath[1:]
+        ud.pkgdir = os.path.join(data.expand('${OSCDIR}', d), ud.host)
+        ud.moddir = os.path.join(ud.pkgdir, relpath, ud.module)
+
+        if 'rev' in ud.parm:
+            ud.revision = ud.parm['rev']
+        else:
+            pv = data.getVar("PV", d, 0)
+            rev = Fetch.srcrev_internal_helper(ud, d)
+            if rev and rev != True:
+                ud.revision = rev
+            else:
+                ud.revision = ""
+
+        ud.localfile = data.expand('%s_%s_%s.tar.gz' % (ud.module.replace('/', '.'), ud.path.replace('/', '.'), ud.revision), d)
+
+        return os.path.join(data.getVar("DL_DIR", d, True), ud.localfile)
+
+    def _buildosccommand(self, ud, d, command):
+        """
+        Build up an ocs commandline based on ud
+        command is "fetch", "update", "info"
+        """
+
+        basecmd = data.expand('${FETCHCMD_osc}', d)
+
+        proto = "ocs"
+        if "proto" in ud.parm:
+            proto = ud.parm["proto"]
+
+        options = []
+
+        config = "-c %s" % self.generate_config(ud, d)
+
+        if ud.revision:
+            options.append("-r %s" % ud.revision)
+
+        coroot = ud.path
+        if coroot.startswith('/'):
+            # Remove leading slash as os.path.join can't cope
+            coroot= coroot[1:]
+
+        if command is "fetch":
+            osccmd = "%s %s co %s/%s %s" % (basecmd, config, coroot, ud.module, " ".join(options))
+        elif command is "update":
+            osccmd = "%s %s up %s" % (basecmd, config, " ".join(options))
+        else:
+            raise FetchError("Invalid osc command %s" % command)
+
+        return osccmd
+
+    def go(self, loc, ud, d):
+        """
+        Fetch url
+        """
+
+        bb.msg.debug(2, bb.msg.domain.Fetcher, "Fetch: checking for module directory '" + ud.moddir + "'")
+
+        if os.access(os.path.join(data.expand('${OSCDIR}', d), ud.path, ud.module), os.R_OK):
+            oscupdatecmd = self._buildosccommand(ud, d, "update")
+            bb.msg.note(1, bb.msg.domain.Fetcher, "Update "+ loc)
+            # update sources there
+            os.chdir(ud.moddir)
+            bb.msg.debug(1, bb.msg.domain.Fetcher, "Running %s" % oscupdatecmd)
+            runfetchcmd(oscupdatecmd, d)
+        else:
+            oscfetchcmd = self._buildosccommand(ud, d, "fetch")
+            bb.msg.note(1, bb.msg.domain.Fetcher, "Fetch " + loc)
+            # check out sources there
+            bb.mkdirhier(ud.pkgdir)
+            os.chdir(ud.pkgdir)
+            bb.msg.debug(1, bb.msg.domain.Fetcher, "Running %s" % oscfetchcmd)
+            runfetchcmd(oscfetchcmd, d)
+
+        os.chdir(os.path.join(ud.pkgdir + ud.path))
+        # tar them up to a defined filename
+        try:
+            runfetchcmd("tar -czf %s %s" % (ud.localpath, ud.module), d)
+        except:
+            t, v, tb = sys.exc_info()
+            try:
+                os.unlink(ud.localpath)
+            except OSError:
+                pass
+            raise t, v, tb
+
+    def supports_srcrev(self):
+        return False
+
+    def generate_config(self, ud, d):
+        """
+        Generate a .oscrc to be used for this run.
+        """
+
+        config_path = "%s/oscrc" % data.expand('${OSCDIR}', d)
+        if (os.path.exists(config_path)):
+            os.remove(config_path)
+
+        f = open(config_path, 'w')
+        f.write("[general]\n")
+        f.write("apisrv = %s\n" % ud.host)
+        f.write("scheme = http\n")
+        f.write("su-wrapper = su -c\n")
+        f.write("build-root = %s\n" % data.expand('${WORKDIR}', d))
+        f.write("urllist = http://moblin-obs.jf.intel.com:8888/build/%(project)s/%(repository)s/%(buildarch)s/:full/%(name)s.rpm\n")
+        f.write("extra-pkgs = gzip\n")
+        f.write("\n")
+        f.write("[%s]\n" % ud.host)
+        f.write("user = %s\n" % ud.parm["user"])
+        f.write("pass = %s\n" % ud.parm["pswd"])
+        f.close()
+
+        return config_path
--- a/bitbake/lib/bb/fetch/perforce.py
+++ b/bitbake/lib/bb/fetch/perforce.py
@@ -25,26 +25,26 @@ BitBake build tools.
 #
 # Based on functions from the base bb module, Copyright 2003 Holger Schurig

-import os, re
+from future_builtins import zip
+import os
 import bb
 from   bb import data
 from   bb.fetch import Fetch
 from   bb.fetch import FetchError
-from   bb.fetch import MissingParameterError

 class Perforce(Fetch):
    def supports(self, url, ud, d):
        return ud.type in ['p4']

-    def doparse(url,d):
-        parm=[]
+    def doparse(url, d):
+        parm = {}
        path = url.split("://")[1]
        delim = path.find("@");
        if delim != -1:
-            (user,pswd,host,port) = path.split('@')[0].split(":")
+            (user, pswd, host, port) = path.split('@')[0].split(":")
            path = path.split('@')[1]
        else:
-            (host,port) = data.getVar('P4PORT', d).split(':')
+            (host, port) = data.getVar('P4PORT', d).split(':')
            user = ""
            pswd = ""

@@ -54,27 +54,28 @@ class Perforce(Fetch):
            plist = path.split(';')
            for item in plist:
                if item.count('='):
-                    (key,value) = item.split('=')
+                    (key, value) = item.split('=')
                    keys.append(key)
                    values.append(value)

-            parm = dict(zip(keys,values))
+            parm = dict(zip(keys, values))
        path = "//" + path.split(';')[0]
        host += ":%s" % (port)
        parm["cset"] = Perforce.getcset(d, path, host, user, pswd, parm)

-        return host,path,user,pswd,parm
+        return host, path, user, pswd, parm
    doparse = staticmethod(doparse)

-    def getcset(d, depot,host,user,pswd,parm):
+    def getcset(d, depot, host, user, pswd, parm):
+        p4opt = ""
        if "cset" in parm:
            return parm["cset"];
        if user:
-            data.setVar('P4USER', user, d)
+            p4opt += " -u %s" % (user)
        if pswd:
-            data.setVar('P4PASSWD', pswd, d)
+            p4opt += " -P %s" % (pswd)
        if host:
-            data.setVar('P4PORT', host, d)
+            p4opt += " -p %s" % (host)

        p4date = data.getVar("P4DATE", d, 1)
        if "revision" in parm:
@@ -85,8 +86,8 @@ class Perforce(Fetch):
            depot += "@%s" % (p4date)

        p4cmd = data.getVar('FETCHCOMMAND_p4', d, 1)
-        bb.msg.debug(1, bb.msg.domain.Fetcher, "Running %s changes -m 1 %s" % (p4cmd, depot))
-        p4file = os.popen("%s changes -m 1 %s" % (p4cmd,depot))
+        bb.msg.debug(1, bb.msg.domain.Fetcher, "Running %s%s changes -m 1 %s" % (p4cmd, p4opt, depot))
+        p4file = os.popen("%s%s changes -m 1 %s" % (p4cmd, p4opt, depot))
        cset = p4file.readline().strip()
        bb.msg.debug(1, bb.msg.domain.Fetcher, "READ %s" % (cset))
        if not cset:
@@ -95,9 +96,9 @@ class Perforce(Fetch):
        return cset.split(' ')[1]
    getcset = staticmethod(getcset)

-    def localpath(self, url, ud, d):        
+    def localpath(self, url, ud, d):

-        (host,path,user,pswd,parm) = Perforce.doparse(url,d)
+        (host, path, user, pswd, parm) = Perforce.doparse(url, d)

        # If a label is specified, we use that as our filename

@@ -115,7 +116,7 @@ class Perforce(Fetch):

        cset = Perforce.getcset(d, path, host, user, pswd, parm)

-        ud.localfile = data.expand('%s+%s+%s.tar.gz' % (host,base.replace('/', '.'), cset), d)
+        ud.localfile = data.expand('%s+%s+%s.tar.gz' % (host, base.replace('/', '.'), cset), d)

        return os.path.join(data.getVar("DL_DIR", d, 1), ud.localfile)

@@ -124,12 +125,7 @@ class Perforce(Fetch):
        Fetch urls
        """

-        # try to use the tarball stash
-        if not self.forcefetch(loc, ud, d) and Fetch.try_mirror(d, ud.localfile):
-            bb.msg.debug(1, bb.msg.domain.Fetcher, "%s already exists or was mirrored, skipping perforce checkout." % ud.localpath)
-            return
-
-        (host,depot,user,pswd,parm) = Perforce.doparse(loc, d)
+        (host, depot, user, pswd, parm) = Perforce.doparse(loc, d)

        if depot.find('/...') != -1:
            path = depot[:depot.find('/...')]
@@ -146,14 +142,15 @@ class Perforce(Fetch):
        data.update_data(localdata)

        # Get the p4 command
+        p4opt = ""
        if user:
-            data.setVar('P4USER', user, localdata)
+            p4opt += " -u %s" % (user)

        if pswd:
-            data.setVar('P4PASSWD', pswd, localdata)
+            p4opt += " -P %s" % (pswd)

        if host:
-            data.setVar('P4PORT', host, localdata)
+            p4opt += " -p %s" % (host)

        p4cmd = data.getVar('FETCHCOMMAND', localdata, 1)

@@ -164,27 +161,27 @@ class Perforce(Fetch):
        tmppipe = os.popen(data.getVar('MKTEMPDIRCMD', localdata, 1) or "false")
        tmpfile = tmppipe.readline().strip()
        if not tmpfile:
-            bb.error("Fetch: unable to create temporary directory.. make sure 'mktemp' is in the PATH.")
+            bb.msg.error(bb.msg.domain.Fetcher, "Fetch: unable to create temporary directory.. make sure 'mktemp' is in the PATH.")
            raise FetchError(module)

        if "label" in parm:
-            depot = "%s@%s" % (depot,parm["label"])
+            depot = "%s@%s" % (depot, parm["label"])
        else:
            cset = Perforce.getcset(d, depot, host, user, pswd, parm)
-            depot = "%s@%s" % (depot,cset)
+            depot = "%s@%s" % (depot, cset)

        os.chdir(tmpfile)
        bb.msg.note(1, bb.msg.domain.Fetcher, "Fetch " + loc)
-        bb.msg.note(1, bb.msg.domain.Fetcher, "%s files %s" % (p4cmd, depot))
-        p4file = os.popen("%s files %s" % (p4cmd, depot))
+        bb.msg.note(1, bb.msg.domain.Fetcher, "%s%s files %s" % (p4cmd, p4opt, depot))
+        p4file = os.popen("%s%s files %s" % (p4cmd, p4opt, depot))

        if not p4file:
-            bb.error("Fetch: unable to get the P4 files from %s" % (depot))
+            bb.msg.error(bb.msg.domain.Fetcher, "Fetch: unable to get the P4 files from %s" % (depot))
            raise FetchError(module)

        count = 0

-        for file in p4file: 
+        for file in p4file:
            list = file.split()

            if list[2] == "delete":
@@ -193,11 +190,11 @@ class Perforce(Fetch):
            dest = list[0][len(path)+1:]
            where = dest.find("#")

-            os.system("%s print -o %s/%s %s" % (p4cmd, module,dest[:where],list[0]))
+            os.system("%s%s print -o %s/%s %s" % (p4cmd, p4opt, module, dest[:where], list[0]))
            count = count + 1
-            
+
        if count == 0:
-            bb.error("Fetch:  No files gathered from the P4 fetch")
+            bb.msg.error(bb.msg.domain.Fetcher, "Fetch:  No files gathered from the P4 fetch")
            raise FetchError(module)

        myret = os.system("tar -czf %s %s" % (ud.localpath, module))
@@ -209,5 +206,3 @@ class Perforce(Fetch):
            raise FetchError(module)
        # cleanup
        os.system('rm -rf %s' % tmpfile)
-
-
--- a/bitbake/lib/bb/fetch/repo.py
+++ b/bitbake/lib/bb/fetch/repo.py
@@ -0,0 +1,105 @@
+# ex:ts=4:sw=4:sts=4:et
+# -*- tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*-
+"""
+BitBake "Fetch" repo (git) implementation
+
+"""
+
+# Copyright (C) 2009 Tom Rini <trini@embeddedalley.com>
+#
+# Based on git.py which is:
+#Copyright (C) 2005 Richard Purdie
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License version 2 as
+# published by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License along
+# with this program; if not, write to the Free Software Foundation, Inc.,
+# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+
+import os
+import bb
+from   bb    import data
+from   bb.fetch import Fetch
+from   bb.fetch import runfetchcmd
+
+class Repo(Fetch):
+    """Class to fetch a module or modules from repo (git) repositories"""
+    def supports(self, url, ud, d):
+        """
+        Check to see if a given url can be fetched with repo.
+        """
+        return ud.type in ["repo"]
+
+    def localpath(self, url, ud, d):
+        """
+        We don"t care about the git rev of the manifests repository, but
+        we do care about the manifest to use.  The default is "default".
+        We also care about the branch or tag to be used.  The default is
+        "master".
+        """
+
+        if "protocol" in ud.parm:
+            ud.proto = ud.parm["protocol"]
+        else:
+            ud.proto = "git"
+
+        if "branch" in ud.parm:
+            ud.branch = ud.parm["branch"]
+        else:
+            ud.branch = "master"
+
+        if "manifest" in ud.parm:
+            manifest = ud.parm["manifest"]
+            if manifest.endswith(".xml"):
+                ud.manifest = manifest
+            else:
+                ud.manifest = manifest + ".xml"
+        else:
+            ud.manifest = "default.xml"
+
+        ud.localfile = data.expand("repo_%s%s_%s_%s.tar.gz" % (ud.host, ud.path.replace("/", "."), ud.manifest, ud.branch), d)
+
+        return os.path.join(data.getVar("DL_DIR", d, True), ud.localfile)
+
+    def go(self, loc, ud, d):
+        """Fetch url"""
+
+        if os.access(os.path.join(data.getVar("DL_DIR", d, True), ud.localfile), os.R_OK):
+            bb.msg.debug(1, bb.msg.domain.Fetcher, "%s already exists (or was stashed). Skipping repo init / sync." % ud.localpath)
+            return
+
+        gitsrcname = "%s%s" % (ud.host, ud.path.replace("/", "."))
+        repodir = data.getVar("REPODIR", d, True) or os.path.join(data.getVar("DL_DIR", d, True), "repo")
+        codir = os.path.join(repodir, gitsrcname, ud.manifest)
+
+        if ud.user:
+            username = ud.user + "@"
+        else:
+            username = ""
+
+        bb.mkdirhier(os.path.join(codir, "repo"))
+        os.chdir(os.path.join(codir, "repo"))
+        if not os.path.exists(os.path.join(codir, "repo", ".repo")):
+            runfetchcmd("repo init -m %s -b %s -u %s://%s%s%s" % (ud.manifest, ud.branch, ud.proto, username, ud.host, ud.path), d)
+
+        runfetchcmd("repo sync", d)
+        os.chdir(codir)
+
+        # Create a cache
+        runfetchcmd("tar --exclude=.repo --exclude=.git -czf %s %s" % (ud.localpath, os.path.join(".", "*") ), d)
+
+    def suppports_srcrev(self):
+        return False
+
+    def _build_revision(self, url, ud, d):
+        return ud.manifest
+
+    def _want_sortable_revision(self, url, ud, d):
+        return False
--- a/bitbake/lib/bb/fetch/ssh.py
+++ b/bitbake/lib/bb/fetch/ssh.py
@@ -37,11 +37,9 @@ IETF secsh internet draft:
 # 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.

 import re, os
-import bb
 from   bb import data
 from   bb.fetch import Fetch
 from   bb.fetch import FetchError
-from   bb.fetch import MissingParameterError


 __pattern__ = re.compile(r'''
@@ -116,5 +114,5 @@ class SSH(Fetch):

        (exitstatus, output) = commands.getstatusoutput(cmd)
        if exitstatus != 0:
-            print output
+            print(output)
            raise FetchError('Unable to fetch %s' % url)
--- a/bitbake/lib/bb/fetch/svk.py
+++ b/bitbake/lib/bb/fetch/svk.py
@@ -25,7 +25,7 @@ This implementation is for svk. It is based on the svn implementation
 #
 # Based on functions from the base bb module, Copyright 2003 Holger Schurig

-import os, re
+import os
 import bb
 from   bb import data
 from   bb.fetch import Fetch
@@ -36,7 +36,7 @@ class Svk(Fetch):
    """Class to fetch a module or modules from svk repositories"""
    def supports(self, url, ud, d):
        """
-        Check to see if a given url can be fetched with cvs.
+        Check to see if a given url can be fetched with svk.
        """
        return ud.type in ['svk']

@@ -62,15 +62,12 @@ class Svk(Fetch):
    def go(self, loc, ud, d):
        """Fetch urls"""

-        if not self.forcefetch(loc, ud, d) and Fetch.try_mirror(d, ud.localfile):
-            return
-
        svkroot = ud.host + ud.path

-        svkcmd = "svk co -r {%s} %s/%s" % (date, svkroot, ud.module)
+        svkcmd = "svk co -r {%s} %s/%s" % (ud.date, svkroot, ud.module)

        if ud.revision:
-            svkcmd = "svk co -r %s/%s" % (ud.revision, svkroot, ud.module)
+            svkcmd = "svk co -r %s %s/%s" % (ud.revision, svkroot, ud.module)

        # create temp directory
        localdata = data.createCopy(d)
--- a/bitbake/lib/bb/fetch/svn.py
+++ b/bitbake/lib/bb/fetch/svn.py
@@ -1,17 +1,12 @@
 # ex:ts=4:sw=4:sts=4:et
 # -*- tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*-
 """
-BitBake 'Fetch' implementations
-
-This implementation is for svn. It is based on the cvs implementation.
+BitBake 'Fetch' implementation for svn.

 """

-# Copyright (C) 2004 Marcin Juszkiewicz
-#
-#   Classes for obtaining upstream sources for the
-#   BitBake build tools.
-#   Copyright (C) 2003, 2004  Chris Larson
+# Copyright (C) 2003, 2004  Chris Larson
+# Copyright (C) 2004        Marcin Juszkiewicz
 #
 # This program is free software; you can redistribute it and/or modify
 # it under the terms of the GNU General Public License version 2 as
@@ -28,13 +23,14 @@ This implementation is for svn. It is based on the cvs implementation.
 #
 # Based on functions from the base bb module, Copyright 2003 Holger Schurig

-import os, re
+import os
 import sys
 import bb
 from   bb import data
 from   bb.fetch import Fetch
 from   bb.fetch import FetchError
 from   bb.fetch import MissingParameterError
+from   bb.fetch import runfetchcmd

 class Svn(Fetch):
    """Class to fetch a module or modules from svn repositories"""
@@ -47,32 +43,54 @@ class Svn(Fetch):
    def localpath(self, url, ud, d):
        if not "module" in ud.parm:
            raise MissingParameterError("svn method needs a 'module' parameter")
-        else:
-            ud.module = ud.parm["module"]

-        ud.revision = ""
+        ud.module = ud.parm["module"]
+
+        # Create paths to svn checkouts
+        relpath = ud.path
+        if relpath.startswith('/'):
+            # Remove leading slash as os.path.join can't cope
+            relpath = relpath[1:]
+        ud.pkgdir = os.path.join(data.expand('${SVNDIR}', d), ud.host, relpath)
+        ud.moddir = os.path.join(ud.pkgdir, ud.module)
+
        if 'rev' in ud.parm:
-            ud.revision = ud.parm['rev']
-
-        if ud.revision:
            ud.date = ""
+            ud.revision = ud.parm['rev']
+        elif 'date' in ud.date:
+            ud.date = ud.parm['date']
+            ud.revision = ""
+        else:
+            #
+            # ***Nasty hack***
+            # If DATE in unexpanded PV, use ud.date (which is set from SRCDATE)
+            # Should warn people to switch to SRCREV here
+            #
+            pv = data.getVar("PV", d, 0)
+            if "DATE" in pv:
+                ud.revision = ""
+            else:
+                rev = Fetch.srcrev_internal_helper(ud, d)
+                if rev is True:
+                    ud.revision = self.latest_revision(url, ud, d)
+                    ud.date = ""
+                elif rev:
+                    ud.revision = rev
+                    ud.date = ""
+                else:
+                    ud.revision = ""

        ud.localfile = data.expand('%s_%s_%s_%s_%s.tar.gz' % (ud.module.replace('/', '.'), ud.host, ud.path.replace('/', '.'), ud.revision, ud.date), d)

        return os.path.join(data.getVar("DL_DIR", d, True), ud.localfile)

-    def forcefetch(self, url, ud, d):
-        if (ud.date == "now"):
-            return True
-        return False
+    def _buildsvncommand(self, ud, d, command):
+        """
+        Build up an svn commandline based on ud
+        command is "fetch", "update", "info"
+        """

-    def go(self, loc, ud, d):
-        """Fetch url"""
-
-        # try to use the tarball stash
-        if not self.forcefetch(loc, ud, d) and Fetch.try_mirror(d, ud.localfile):
-            bb.msg.debug(1, bb.msg.domain.Fetcher, "%s already exists or was mirrored, skipping svn checkout." % ud.localpath)
-            return
+        basecmd = data.expand('${FETCHCMD_svn}', d)

        proto = "svn"
        if "proto" in ud.parm:
@@ -84,12 +102,8 @@ class Svn(Fetch):

        svnroot = ud.host + ud.path

-        # either use the revision, or SRCDATE in braces, or nothing for SRCDATE = "now"
+        # either use the revision, or SRCDATE in braces,
        options = []
-        if ud.revision:
-            options.append("-r %s" % ud.revision)
-        elif ud.date != "now":
-            options.append("-r {%s}" % ud.date)

        if ud.user:
            options.append("--username %s" % ud.user)
@@ -97,48 +111,91 @@ class Svn(Fetch):
        if ud.pswd:
            options.append("--password %s" % ud.pswd)

-        localdata = data.createCopy(d)
-        data.setVar('OVERRIDES', "svn:%s" % data.getVar('OVERRIDES', localdata), localdata)
-        data.update_data(localdata)
+        if command is "info":
+            svncmd = "%s info %s %s://%s/%s/" % (basecmd, " ".join(options), proto, svnroot, ud.module)
+        else:
+            suffix = ""
+            if ud.revision:
+                options.append("-r %s" % ud.revision)
+                suffix = "@%s" % (ud.revision)
+            elif ud.date:
+                options.append("-r {%s}" % ud.date)

-        data.setVar('SVNROOT', "%s://%s/%s" % (proto, svnroot, ud.module), localdata)
-        data.setVar('SVNCOOPTS', " ".join(options), localdata)
-        data.setVar('SVNMODULE', ud.module, localdata)
-        svncmd = data.getVar('FETCHCOMMAND', localdata, 1)
-        svnupcmd = data.getVar('UPDATECOMMAND', localdata, 1)
+            if command is "fetch":
+                svncmd = "%s co %s %s://%s/%s%s %s" % (basecmd, " ".join(options), proto, svnroot, ud.module, suffix, ud.module)
+            elif command is "update":
+                svncmd = "%s update %s" % (basecmd, " ".join(options))
+            else:
+                raise FetchError("Invalid svn command %s" % command)

        if svn_rsh:
            svncmd = "svn_RSH=\"%s\" %s" % (svn_rsh, svncmd)
-            svnupcmd = "svn_RSH=\"%s\" %s" % (svn_rsh, svnupcmd)

-        pkg = data.expand('${PN}', d)
-        pkgdir = os.path.join(data.expand('${SVNDIR}', localdata), pkg)
-        moddir = os.path.join(pkgdir, ud.module)
-        bb.msg.debug(2, bb.msg.domain.Fetcher, "Fetch: checking for module directory '" + moddir + "'")
+        return svncmd

-        if os.access(os.path.join(moddir, '.svn'), os.R_OK):
+    def go(self, loc, ud, d):
+        """Fetch url"""
+
+        bb.msg.debug(2, bb.msg.domain.Fetcher, "Fetch: checking for module directory '" + ud.moddir + "'")
+
+        if os.access(os.path.join(ud.moddir, '.svn'), os.R_OK):
+            svnupdatecmd = self._buildsvncommand(ud, d, "update")
            bb.msg.note(1, bb.msg.domain.Fetcher, "Update " + loc)
            # update sources there
-            os.chdir(moddir)
-            bb.msg.debug(1, bb.msg.domain.Fetcher, "Running %s" % svnupcmd)
-            myret = os.system(svnupcmd)
+            os.chdir(ud.moddir)
+            bb.msg.debug(1, bb.msg.domain.Fetcher, "Running %s" % svnupdatecmd)
+            runfetchcmd(svnupdatecmd, d)
        else:
+            svnfetchcmd = self._buildsvncommand(ud, d, "fetch")
            bb.msg.note(1, bb.msg.domain.Fetcher, "Fetch " + loc)
            # check out sources there
-            bb.mkdirhier(pkgdir)
-            os.chdir(pkgdir)
-            bb.msg.debug(1, bb.msg.domain.Fetcher, "Running %s" % svncmd)
-            myret = os.system(svncmd)
+            bb.mkdirhier(ud.pkgdir)
+            os.chdir(ud.pkgdir)
+            bb.msg.debug(1, bb.msg.domain.Fetcher, "Running %s" % svnfetchcmd)
+            runfetchcmd(svnfetchcmd, d)

-        if myret != 0:
-            raise FetchError(ud.module)
-
-        os.chdir(pkgdir)
+        os.chdir(ud.pkgdir)
        # tar them up to a defined filename
-        myret = os.system("tar -czf %s %s" % (ud.localpath, os.path.basename(ud.module)))
-        if myret != 0:
+        try:
+            runfetchcmd("tar -czf %s %s" % (ud.localpath, ud.module), d)
+        except:
+            t, v, tb = sys.exc_info()
            try:
                os.unlink(ud.localpath)
            except OSError:
                pass
-            raise FetchError(ud.module)
+            raise t, v, tb
+
+    def suppports_srcrev(self):
+        return True
+
+    def _revision_key(self, url, ud, d):
+        """
+        Return a unique key for the url
+        """
+        return "svn:" + ud.moddir
+
+    def _latest_revision(self, url, ud, d):
+        """
+        Return the latest upstream revision number
+        """
+        bb.msg.debug(2, bb.msg.domain.Fetcher, "SVN fetcher hitting network for %s" % url)
+
+        output = runfetchcmd("LANG=C LC_ALL=C " + self._buildsvncommand(ud, d, "info"), d, True)
+
+        revision = None
+        for line in output.splitlines():
+            if "Last Changed Rev" in line:
+                revision = line.split(":")[1].strip()
+
+        return revision
+
+    def _sortable_revision(self, url, ud, d):
+        """
+        Return a sortable revision number which in our case is the revision number
+        """
+
+        return self._build_revision(url, ud, d)
+
+    def _build_revision(self, url, ud, d):
+        return ud.revision
--- a/bitbake/lib/bb/fetch/wget.py
+++ b/bitbake/lib/bb/fetch/wget.py
@@ -25,51 +25,58 @@ BitBake build tools.
 #
 # Based on functions from the base bb module, Copyright 2003 Holger Schurig

-import os, re
+import os
 import bb
 from   bb import data
 from   bb.fetch import Fetch
 from   bb.fetch import FetchError
-from   bb.fetch import uri_replace
+from   bb.fetch import encodeurl, decodeurl
+from   bb.fetch import runfetchcmd

 class Wget(Fetch):
    """Class to fetch urls via 'wget'"""
    def supports(self, url, ud, d):
        """
-        Check to see if a given url can be fetched with cvs.
+        Check to see if a given url can be fetched with wget.
        """
-        return ud.type in ['http','https','ftp']
+        return ud.type in ['http', 'https', 'ftp']

    def localpath(self, url, ud, d):

-        url = bb.encodeurl([ud.type, ud.host, ud.path, ud.user, ud.pswd, {}])
+        url = encodeurl([ud.type, ud.host, ud.path, ud.user, ud.pswd, {}])
        ud.basename = os.path.basename(ud.path)
        ud.localfile = data.expand(os.path.basename(url), d)

        return os.path.join(data.getVar("DL_DIR", d, True), ud.localfile)

-    def go(self, uri, ud, d):
+    def go(self, uri, ud, d, checkonly = False):
        """Fetch urls"""

        def fetch_uri(uri, ud, d):
-            if os.path.exists(ud.localpath):
+            if checkonly:
+                fetchcmd = data.getVar("CHECKCOMMAND", d, 1)
+            elif os.path.exists(ud.localpath):
                # file exists, but we didnt complete it.. trying again..
                fetchcmd = data.getVar("RESUMECOMMAND", d, 1)
            else:
                fetchcmd = data.getVar("FETCHCOMMAND", d, 1)

-            bb.msg.note(1, bb.msg.domain.Fetcher, "fetch " + uri)
-            fetchcmd = fetchcmd.replace("${URI}", uri)
-            fetchcmd = fetchcmd.replace("${FILE}", ud.basename)
-            bb.msg.debug(2, bb.msg.domain.Fetcher, "executing " + fetchcmd)
-            ret = os.system(fetchcmd)
-            if ret != 0:
-                return False
+            uri = uri.split(";")[0]
+            uri_decoded = list(decodeurl(uri))
+            uri_type = uri_decoded[0]
+            uri_host = uri_decoded[1]

-            # check if sourceforge did send us to the mirror page
-            if not os.path.exists(ud.localpath):
-                os.system("rm %s*" % ud.localpath) # FIXME shell quote it
-                bb.msg.debug(2, bb.msg.domain.Fetcher, "sourceforge.net send us to the mirror on %s" % ud.basename)
+            fetchcmd = fetchcmd.replace("${URI}", uri.split(";")[0])
+            fetchcmd = fetchcmd.replace("${FILE}", ud.basename)
+
+            bb.msg.note(1, bb.msg.domain.Fetcher, "fetch " + uri)
+            bb.msg.debug(2, bb.msg.domain.Fetcher, "executing " + fetchcmd)
+            runfetchcmd(fetchcmd, d)
+
+            # Sanity check since wget can pretend it succeed when it didn't
+            # Also, this used to happen if sourceforge sent us to the mirror page
+            if not os.path.exists(ud.localpath) and not checkonly:
+                bb.msg.debug(2, bb.msg.domain.Fetcher, "The fetch command for %s returned success but %s doesn't exist?..." % (uri, ud.localpath))
                return False

            return True
@@ -78,22 +85,11 @@ class Wget(Fetch):
        data.setVar('OVERRIDES', "wget:" + data.getVar('OVERRIDES', localdata), localdata)
        data.update_data(localdata)

-        premirrors = [ i.split() for i in (data.getVar('PREMIRRORS', localdata, 1) or "").split('\n') if i ]
-        for (find, replace) in premirrors:
-            newuri = uri_replace(uri, find, replace, d)
-            if newuri != uri:
-                if fetch_uri(newuri, ud, localdata):
-                    return
-
        if fetch_uri(uri, ud, localdata):
-            return
-
-        # try mirrors
-        mirrors = [ i.split() for i in (data.getVar('MIRRORS', localdata, 1) or "").split('\n') if i ]
-        for (find, replace) in mirrors:
-            newuri = uri_replace(uri, find, replace, d)
-            if newuri != uri:
-                if fetch_uri(newuri, ud, localdata):
-                    return
+            return True

        raise FetchError(uri)
+
+
+    def checkstatus(self, uri, ud, d):
+        return self.go(uri, ud, d, True)
--- a/bitbake/lib/bb/manifest.py
+++ b/bitbake/lib/bb/manifest.py
@@ -1,144 +0,0 @@
-# ex:ts=4:sw=4:sts=4:et
-# -*- tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*-
-#
-# Copyright (C) 2003, 2004  Chris Larson
-# 
-# This program is free software; you can redistribute it and/or modify
-# it under the terms of the GNU General Public License version 2 as
-# published by the Free Software Foundation.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License along
-# with this program; if not, write to the Free Software Foundation, Inc.,
-# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-import os, sys
-import bb, bb.data
-
-def getfields(line):
-    fields = {}
-    fieldmap = ( "pkg", "src", "dest", "type", "mode", "uid", "gid", "major", "minor", "start", "inc", "count" )
-    for f in xrange(len(fieldmap)):
-        fields[fieldmap[f]] = None
-
-    if not line:
-        return None
-
-    splitline = line.split()
-    if not len(splitline):
-        return None
-
-    try:
-        for f in xrange(len(fieldmap)):
-            if splitline[f] == '-':
-                continue
-            fields[fieldmap[f]] = splitline[f]
-    except IndexError:
-        pass
-    return fields
-
-def parse (mfile, d):
-    manifest = []
-    while 1:
-        line = mfile.readline()
-        if not line:
-            break
-        if line.startswith("#"):
-            continue
-        fields = getfields(line)
-        if not fields:
-            continue
-        manifest.append(fields)
-    return manifest
-
-def emit (func, manifest, d):
-#str = "%s () {\n" % func
-    str = ""
-    for line in manifest:
-        emittedline = emit_line(func, line, d)
-        if not emittedline:
-            continue
-        str += emittedline + "\n"
-#       str += "}\n"
-    return str
-
-def mangle (func, line, d):
-    import copy
-    newline = copy.copy(line)
-    src = bb.data.expand(newline["src"], d)
-
-    if src:
-        if not os.path.isabs(src):
-            src = "${WORKDIR}/" + src
-
-    dest = newline["dest"]
-    if not dest:
-        return
-
-    if dest.startswith("/"):
-        dest = dest[1:]
-
-    if func is "do_install":
-        dest = "${D}/" + dest
-
-    elif func is "do_populate":
-        dest = "${WORKDIR}/install/" + newline["pkg"] + "/" + dest
-
-    elif func is "do_stage":
-        varmap = {}
-        varmap["${bindir}"] = "${STAGING_DIR}/${HOST_SYS}/bin"
-        varmap["${libdir}"] = "${STAGING_DIR}/${HOST_SYS}/lib"
-        varmap["${includedir}"] = "${STAGING_DIR}/${HOST_SYS}/include"
-        varmap["${datadir}"] = "${STAGING_DATADIR}"
-
-        matched = 0
-        for key in varmap.keys():
-            if dest.startswith(key):
-                dest = varmap[key] + "/" + dest[len(key):]
-                matched = 1
-        if not matched:
-            newline = None
-            return
-    else:
-        newline = None
-        return
-
-    newline["src"] = src
-    newline["dest"] = dest
-    return newline
-
-def emit_line (func, line, d):
-    import copy
-    newline = copy.deepcopy(line)
-    newline = mangle(func, newline, d)
-    if not newline:
-        return None
-
-    str = ""
-    type = newline["type"]
-    mode = newline["mode"]
-    src = newline["src"]
-    dest = newline["dest"]
-    if type is "d":
-        str = "install -d "
-        if mode:
-            str += "-m %s " % mode
-        str += dest
-    elif type is "f":
-        if not src:
-            return None
-        if dest.endswith("/"):
-            str = "install -d "
-            str += dest + "\n"
-            str += "install "
-        else:
-            str = "install -D "
-        if mode:
-            str += "-m %s " % mode
-        str += src + " " + dest
-    del newline
-    return str
--- a/bitbake/lib/bb/methodpool.py
+++ b/bitbake/lib/bb/methodpool.py
@@ -27,7 +27,7 @@
    a method pool to do this task.

    This pool will be used to compile and execute the functions. It
-    will be smart enough to 
+    will be smart enough to
 """

 from bb.utils import better_compile, better_exec
@@ -43,8 +43,8 @@ def insert_method(modulename, code, fn):
    Add code of a module should be added. The methods
    will be simply added, no checking will be done
    """
-    comp = better_compile(code, "<bb>", fn )
-    better_exec(comp, __builtins__, code, fn)
+    comp = better_compile(code, modulename, fn )
+    better_exec(comp, None, code, fn)

    # now some instrumentation
    code = comp.co_names
@@ -59,7 +59,7 @@ def insert_method(modulename, code, fn):
 def check_insert_method(modulename, code, fn):
    """
    Add the code if it wasnt added before. The module
-    name will be used for that 
+    name will be used for that

    Variables:
        @modulename a short name e.g. base.bbclass
@@ -81,4 +81,4 @@ def get_parsed_dict():
    """
    shortcut
    """
-    return _parsed_methods    
+    return _parsed_methods
--- a/bitbake/lib/bb/msg.py
+++ b/bitbake/lib/bb/msg.py
@@ -22,33 +22,40 @@ Message handling infrastructure for bitbake
 # with this program; if not, write to the Free Software Foundation, Inc.,
 # 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.

-import sys, os, re, bb
-from bb import utils, event
-
-debug_level = {}
+import sys
+import collections
+import bb
+import bb.event

+debug_level = collections.defaultdict(lambda: 0)
 verbose = False

-domain = bb.utils.Enum(
-    'Build',
-    'Cache',
-    'Collection',
-    'Data',
-    'Depends',
-    'Fetcher',
-    'Parsing',
-    'Provider',
-    'RunQueue',
-    'TaskData',
-    'Util')
+def _NamedTuple(name, fields):
+    Tuple = collections.namedtuple(name, " ".join(fields))
+    return Tuple(*range(len(fields)))
+
+domain = _NamedTuple("Domain", (
+    "Default",
+    "Build",
+    "Cache",
+    "Collection",
+    "Data",
+    "Depends",
+    "Fetcher",
+    "Parsing",
+    "PersistData",
+    "Provider",
+    "RunQueue",
+    "TaskData",
+    "Util"))


 class MsgBase(bb.event.Event):
    """Base class for messages"""

-    def __init__(self, msg, d ):
+    def __init__(self, msg):
        self._message = msg
-        event.Event.__init__(self, d)
+        bb.event.Event.__init__(self)

 class MsgDebug(MsgBase):
    """Debug Message"""
@@ -65,72 +72,73 @@ class MsgError(MsgBase):
 class MsgFatal(MsgBase):
    """Fatal Message"""

+class MsgPlain(MsgBase):
+    """General output"""
+
 #
 # Message control functions
 #

 def set_debug_level(level):
-    bb.msg.debug_level = {}
-    for domain in bb.msg.domain:
-        bb.msg.debug_level[domain] = level
-    bb.msg.debug_level['default'] = level
+    for d in domain:
+        debug_level[d] = level
+    debug_level[domain.Default] = level
+
+def get_debug_level(msgdomain = domain.Default):
+    return debug_level[msgdomain]

 def set_verbose(level):
-    bb.msg.verbose = level
+    verbose = level

-def set_debug_domains(domains):
-    for domain in domains:
-        found = False
-        for ddomain in bb.msg.domain:
-            if domain == str(ddomain):
-                bb.msg.debug_level[ddomain] = bb.msg.debug_level[ddomain] + 1
-                found = True
-        if not found:
-            std_warn("Logging domain %s is not valid, ignoring" % domain)
+def set_debug_domains(strdomains):
+    for domainstr in strdomains:
+        for d in domain:
+            if domain._fields[d] == domainstr:
+                debug_level[d] += 1
+                break
+        else:
+            warn(None, "Logging domain %s is not valid, ignoring" % domainstr)

 #
 # Message handling functions
 #

-def debug(level, domain, msg, fn = None):
-    if debug_level[domain] >= level:
-        bb.event.fire(MsgDebug(msg, None))
-        print 'DEBUG: ' + msg
+def debug(level, msgdomain, msg, fn = None):
+    if not msgdomain:
+        msgdomain = domain.Default

-def note(level, domain, msg, fn = None):
-    if level == 1 or verbose or debug_level[domain] >= 1:
-        std_note(msg)
+    if debug_level[msgdomain] >= level:
+        bb.event.fire(MsgDebug(msg), None)
+        if bb.event.useStdout:
+            print('DEBUG: %s' % (msg))

-def warn(domain, msg, fn = None):
-    std_warn(msg)
+def note(level, msgdomain, msg, fn = None):
+    if not msgdomain:
+        msgdomain = domain.Default

-def error(domain, msg, fn = None):
-    std_error(msg)
+    if level == 1 or verbose or debug_level[msgdomain] >= 1:
+        bb.event.fire(MsgNote(msg), None)
+        if bb.event.useStdout:
+            print('NOTE: %s' % (msg))

-def fatal(domain, msg, fn = None):
-    std_fatal(msg)
+def warn(msgdomain, msg, fn = None):
+    bb.event.fire(MsgWarn(msg), None)
+    if bb.event.useStdout:
+        print('WARNING: %s' % (msg))

-#
-# Compatibility functions for the original message interface
-#
-def std_debug(lvl, msg):
-    if debug_level['default'] >= lvl:
-        bb.event.fire(MsgDebug(msg, None))
-        print 'DEBUG: ' + msg
+def error(msgdomain, msg, fn = None):
+    bb.event.fire(MsgError(msg), None)
+    if bb.event.useStdout:
+       print('ERROR: %s' % (msg))

-def std_note(msg):
-    bb.event.fire(MsgNote(msg, None))
-    print 'NOTE: ' + msg
+def fatal(msgdomain, msg, fn = None):
+    bb.event.fire(MsgFatal(msg), None)

-def std_warn(msg):
-    bb.event.fire(MsgWarn(msg, None))
-    print 'WARNING: ' + msg
-
-def std_error(msg):
-    bb.event.fire(MsgError(msg, None))
-    print 'ERROR: ' + msg
-
-def std_fatal(msg):
-    bb.event.fire(MsgFatal(msg, None))
-    print 'ERROR: ' + msg
+    if bb.event.useStdout:
+        print('FATAL: %s' % (msg))
    sys.exit(1)
+
+def plain(msg, fn = None):
+    bb.event.fire(MsgPlain(msg), None)
+    if bb.event.useStdout:
+        print(msg)
--- a/bitbake/lib/bb/parse/init.py
+++ b/bitbake/lib/bb/parse/init.py
@@ -24,11 +24,11 @@ File parsers for the BitBake build tools.
 #
 # Based on functions from the base bb module, Copyright 2003 Holger Schurig

-__all__ = [ 'ParseError', 'SkipPackage', 'cached_mtime', 'mark_dependency',
-            'supports', 'handle', 'init' ]
 handlers = []

 import bb, os
+import bb.utils
+import bb.siggen

 class ParseError(Exception):
    """Exception raised when parsing fails"""
@@ -38,23 +38,27 @@ class SkipPackage(Exception):

 __mtime_cache = {}
 def cached_mtime(f):
-    if not __mtime_cache.has_key(f):
+    if f not in __mtime_cache:
        __mtime_cache[f] = os.stat(f)[8]
    return __mtime_cache[f]

 def cached_mtime_noerror(f):
-    if not __mtime_cache.has_key(f):
+    if f not in __mtime_cache:
        try:
            __mtime_cache[f] = os.stat(f)[8]
        except OSError:
            return 0
    return __mtime_cache[f]

+def update_mtime(f):
+    __mtime_cache[f] = os.stat(f)[8]
+    return __mtime_cache[f]
+
 def mark_dependency(d, f):
    if f.startswith('./'):
        f = "%s/%s" % (os.getcwd(), f[2:])
-    deps = bb.data.getVar('__depends', d) or []
-    deps.append( (f, cached_mtime(f)) )
+    deps = bb.data.getVar('__depends', d) or set()
+    deps.update([(f, cached_mtime(f))])
    bb.data.setVar('__depends', deps, d)

 def supports(fn, data):
@@ -76,5 +80,39 @@ def init(fn, data):
        if h['supports'](fn):
            return h['init'](data)

+def init_parser(d, dumpsigs):
+    bb.parse.siggen = bb.siggen.init(d, dumpsigs)

-from parse_py import __version__, ConfHandler, BBHandler
+def resolve_file(fn, d):
+    if not os.path.isabs(fn):
+        bbpath = bb.data.getVar("BBPATH", d, True)
+        newfn = bb.which(bbpath, fn)
+        if not newfn:
+            raise IOError("file %s not found in %s" % (fn, bbpath))
+        fn = newfn
+
+    bb.msg.debug(2, bb.msg.domain.Parsing, "LOAD %s" % fn)
+    return fn
+
+# Used by OpenEmbedded metadata
+__pkgsplit_cache__={}
+def vars_from_file(mypkg, d):
+    if not mypkg:
+        return (None, None, None)
+    if mypkg in __pkgsplit_cache__:
+        return __pkgsplit_cache__[mypkg]
+
+    myfile = os.path.splitext(os.path.basename(mypkg))
+    parts = myfile[0].split('_')
+    __pkgsplit_cache__[mypkg] = parts
+    if len(parts) > 3:
+        raise ParseError("Unable to generate default variables from the filename: %s (too many underscores)" % mypkg)
+    exp = 3 - len(parts)
+    tmplist = []
+    while exp != 0:
+        exp -= 1
+        tmplist.append(None)
+    parts.extend(tmplist)
+    return parts
+
+from bb.parse.parse_py import __version__, ConfHandler, BBHandler
--- a/bitbake/lib/bb/parse/ast.py
+++ b/bitbake/lib/bb/parse/ast.py
@@ -0,0 +1,445 @@
+# ex:ts=4:sw=4:sts=4:et
+# -*- tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*-
+"""
+ AbstractSyntaxTree classes for the Bitbake language
+"""
+
+# Copyright (C) 2003, 2004 Chris Larson
+# Copyright (C) 2003, 2004 Phil Blundell
+# Copyright (C) 2009 Holger Hans Peter Freyther
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License version 2 as
+# published by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License along
+# with this program; if not, write to the Free Software Foundation, Inc.,
+# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+
+from __future__ import absolute_import
+from future_builtins import filter
+import bb, re, string
+from bb import methodpool
+import itertools
+
+__word__ = re.compile(r"\S+")
+__parsed_methods__ = bb.methodpool.get_parsed_dict()
+_bbversions_re = re.compile(r"\[(?P<from>[0-9]+)-(?P<to>[0-9]+)\]")
+
+class StatementGroup(list):
+    def eval(self, data):
+        for statement in self:
+            statement.eval(data)
+
+class AstNode(object):
+    pass
+
+class IncludeNode(AstNode):
+    def __init__(self, what_file, fn, lineno, force):
+        self.what_file = what_file
+        self.from_fn = fn
+        self.from_lineno = lineno
+        self.force = force
+
+    def eval(self, data):
+        """
+        Include the file and evaluate the statements
+        """
+        s = bb.data.expand(self.what_file, data)
+        bb.msg.debug(3, bb.msg.domain.Parsing, "CONF %s:%d: including %s" % (self.from_fn, self.from_lineno, s))
+
+        # TODO: Cache those includes... maybe not here though
+        if self.force:
+            bb.parse.ConfHandler.include(self.from_fn, s, data, "include required")
+        else:
+            bb.parse.ConfHandler.include(self.from_fn, s, data, False)
+
+class ExportNode(AstNode):
+    def __init__(self, var):
+        self.var = var
+
+    def eval(self, data):
+        bb.data.setVarFlag(self.var, "export", 1, data)
+
+class DataNode(AstNode):
+    """
+    Various data related updates. For the sake of sanity
+    we have one class doing all this. This means that all
+    this need to be re-evaluated... we might be able to do
+    that faster with multiple classes.
+    """
+    def __init__(self, groupd):
+        self.groupd = groupd
+
+    def getFunc(self, key, data):
+        if 'flag' in self.groupd and self.groupd['flag'] != None:
+            return bb.data.getVarFlag(key, self.groupd['flag'], data)
+        else:
+            return bb.data.getVar(key, data)
+
+    def eval(self, data):
+        groupd = self.groupd
+        key = groupd["var"]
+        if "exp" in groupd and groupd["exp"] != None:
+            bb.data.setVarFlag(key, "export", 1, data)
+        if "ques" in groupd and groupd["ques"] != None:
+            val = self.getFunc(key, data)
+            if val == None:
+                val = groupd["value"]
+        elif "colon" in groupd and groupd["colon"] != None:
+            e = data.createCopy()
+            bb.data.update_data(e)
+            val = bb.data.expand(groupd["value"], e)
+        elif "append" in groupd and groupd["append"] != None:
+            val = "%s %s" % ((self.getFunc(key, data) or ""), groupd["value"])
+        elif "prepend" in groupd and groupd["prepend"] != None:
+            val = "%s %s" % (groupd["value"], (self.getFunc(key, data) or ""))
+        elif "postdot" in groupd and groupd["postdot"] != None:
+            val = "%s%s" % ((self.getFunc(key, data) or ""), groupd["value"])
+        elif "predot" in groupd and groupd["predot"] != None:
+            val = "%s%s" % (groupd["value"], (self.getFunc(key, data) or ""))
+        else:
+            val = groupd["value"]
+
+        if 'flag' in groupd and groupd['flag'] != None:
+            bb.data.setVarFlag(key, groupd['flag'], val, data)
+        elif groupd["lazyques"]:
+            assigned = bb.data.getVar("__lazy_assigned", data) or []
+            assigned.append(key)
+            bb.data.setVar("__lazy_assigned", assigned, data)
+            bb.data.setVarFlag(key, "defaultval", val, data)
+        else:
+            bb.data.setVar(key, val, data)
+
+class MethodNode:
+    def __init__(self, func_name, body, lineno, fn):
+        self.func_name = func_name
+        self.body = body
+        self.fn = fn
+        self.lineno = lineno
+
+    def eval(self, data):
+        if self.func_name == "__anonymous":
+            funcname = ("__anon_%s_%s" % (self.lineno, self.fn.translate(string.maketrans('/.+-', '____'))))
+            if not funcname in bb.methodpool._parsed_fns:
+                text = "def %s(d):\n" % (funcname) + '\n'.join(self.body)
+                bb.methodpool.insert_method(funcname, text, self.fn)
+            anonfuncs = bb.data.getVar('__BBANONFUNCS', data) or []
+            anonfuncs.append(funcname)
+            bb.data.setVar('__BBANONFUNCS', anonfuncs, data)
+        else:
+            bb.data.setVarFlag(self.func_name, "func", 1, data)
+            bb.data.setVar(self.func_name, '\n'.join(self.body), data)
+
+class PythonMethodNode(AstNode):
+    def __init__(self, funcname, root, body, fn):
+        self.func_name = funcname
+        self.root = root
+        self.body = body
+        self.fn = fn
+
+    def eval(self, data):
+        # Note we will add root to parsedmethods after having parse
+        # 'this' file. This means we will not parse methods from
+        # bb classes twice
+        text = '\n'.join(self.body)
+        if not bb.methodpool.parsed_module(self.root):
+            bb.methodpool.insert_method(self.root, text, self.fn)
+        bb.data.setVarFlag(self.func_name, "func", 1, data)
+        bb.data.setVarFlag(self.func_name, "python", 1, data)
+        bb.data.setVar(self.func_name, text, data)
+
+class MethodFlagsNode(AstNode):
+    def __init__(self, key, m):
+        self.key = key
+        self.m = m
+
+    def eval(self, data):
+        if bb.data.getVar(self.key, data):
+            # clean up old version of this piece of metadata, as its
+            # flags could cause problems
+            bb.data.setVarFlag(self.key, 'python', None, data)
+            bb.data.setVarFlag(self.key, 'fakeroot', None, data)
+        if self.m.group("py") is not None:
+            bb.data.setVarFlag(self.key, "python", "1", data)
+        else:
+            bb.data.delVarFlag(self.key, "python", data)
+        if self.m.group("fr") is not None:
+            bb.data.setVarFlag(self.key, "fakeroot", "1", data)
+        else:
+            bb.data.delVarFlag(self.key, "fakeroot", data)
+
+class ExportFuncsNode(AstNode):
+    def __init__(self, fns, classes):
+        self.n = __word__.findall(fns)
+        self.classes = classes
+
+    def eval(self, data):
+        for f in self.n:
+            allvars = []
+            allvars.append(f)
+            allvars.append(self.classes[-1] + "_" + f)
+
+            vars = [[ allvars[0], allvars[1] ]]
+            if len(self.classes) > 1 and self.classes[-2] is not None:
+                allvars.append(self.classes[-2] + "_" + f)
+                vars = []
+                vars.append([allvars[2], allvars[1]])
+                vars.append([allvars[0], allvars[2]])
+
+            for (var, calledvar) in vars:
+                if bb.data.getVar(var, data) and not bb.data.getVarFlag(var, 'export_func', data):
+                    continue
+
+                if bb.data.getVar(var, data):
+                    bb.data.setVarFlag(var, 'python', None, data)
+                    bb.data.setVarFlag(var, 'func', None, data)
+
+                for flag in [ "func", "python" ]:
+                    if bb.data.getVarFlag(calledvar, flag, data):
+                        bb.data.setVarFlag(var, flag, bb.data.getVarFlag(calledvar, flag, data), data)
+                for flag in [ "dirs" ]:
+                    if bb.data.getVarFlag(var, flag, data):
+                        bb.data.setVarFlag(calledvar, flag, bb.data.getVarFlag(var, flag, data), data)
+
+                if bb.data.getVarFlag(calledvar, "python", data):
+                    bb.data.setVar(var, "\tbb.build.exec_func('" + calledvar + "', d)\n", data)
+                else:
+                    bb.data.setVar(var, "\t" + calledvar + "\n", data)
+                bb.data.setVarFlag(var, 'export_func', '1', data)
+
+class AddTaskNode(AstNode):
+    def __init__(self, func, before, after):
+        self.func = func
+        self.before = before
+        self.after = after
+
+    def eval(self, data):
+        var = self.func
+        if self.func[:3] != "do_":
+            var = "do_" + self.func
+
+        bb.data.setVarFlag(var, "task", 1, data)
+        bbtasks = bb.data.getVar('__BBTASKS', data) or []
+        if not var in bbtasks:
+            bbtasks.append(var)
+        bb.data.setVar('__BBTASKS', bbtasks, data)
+
+        existing = bb.data.getVarFlag(var, "deps", data) or []
+        if self.after is not None:
+            # set up deps for function
+            for entry in self.after.split():
+                if entry not in existing:
+                    existing.append(entry)
+        bb.data.setVarFlag(var, "deps", existing, data)
+        if self.before is not None:
+            # set up things that depend on this func
+            for entry in self.before.split():
+                existing = bb.data.getVarFlag(entry, "deps", data) or []
+                if var not in existing:
+                    bb.data.setVarFlag(entry, "deps", [var] + existing, data)
+
+class BBHandlerNode(AstNode):
+    def __init__(self, fns):
+        self.hs = __word__.findall(fns)
+
+    def eval(self, data):
+        bbhands = bb.data.getVar('__BBHANDLERS', data) or []
+        for h in self.hs:
+            bbhands.append(h)
+            bb.data.setVarFlag(h, "handler", 1, data)
+        bb.data.setVar('__BBHANDLERS', bbhands, data)
+
+class InheritNode(AstNode):
+    def __init__(self, files):
+        self.n = __word__.findall(files)
+
+    def eval(self, data):
+        bb.parse.BBHandler.inherit(self.n, data)
+
+def handleInclude(statements, m, fn, lineno, force):
+    statements.append(IncludeNode(m.group(1), fn, lineno, force))
+
+def handleExport(statements, m):
+    statements.append(ExportNode(m.group(1)))
+
+def handleData(statements, groupd):
+    statements.append(DataNode(groupd))
+
+def handleMethod(statements, func_name, lineno, fn, body):
+    statements.append(MethodNode(func_name, body, lineno, fn))
+
+def handlePythonMethod(statements, funcname, root, body, fn):
+    statements.append(PythonMethodNode(funcname, root, body, fn))
+
+def handleMethodFlags(statements, key, m):
+    statements.append(MethodFlagsNode(key, m))
+
+def handleExportFuncs(statements, m, classes):
+    statements.append(ExportFuncsNode(m.group(1), classes))
+
+def handleAddTask(statements, m):
+    func = m.group("func")
+    before = m.group("before")
+    after = m.group("after")
+    if func is None:
+        return
+
+    statements.append(AddTaskNode(func, before, after))
+
+def handleBBHandlers(statements, m):
+    statements.append(BBHandlerNode(m.group(1)))
+
+def handleInherit(statements, m):
+    files = m.group(1)
+    n = __word__.findall(files)
+    statements.append(InheritNode(m.group(1)))
+
+def finalize(fn, d, variant = None):
+    for lazykey in bb.data.getVar("__lazy_assigned", d) or ():
+        if bb.data.getVar(lazykey, d) is None:
+            val = bb.data.getVarFlag(lazykey, "defaultval", d)
+            bb.data.setVar(lazykey, val, d)
+
+    bb.data.expandKeys(d)
+    bb.data.update_data(d)
+    code = []
+    for funcname in bb.data.getVar("__BBANONFUNCS", d) or []:
+        code.append("%s(d)" % funcname)
+    bb.utils.simple_exec("\n".join(code), {"d": d})
+    bb.data.update_data(d)
+
+    all_handlers = {}
+    for var in bb.data.getVar('__BBHANDLERS', d) or []:
+        # try to add the handler
+        handler = bb.data.getVar(var, d)
+        bb.event.register(var, handler)
+
+    tasklist = bb.data.getVar('__BBTASKS', d) or []
+    bb.build.add_tasks(tasklist, d)
+
+    bb.parse.siggen.finalise(fn, d, variant)
+
+    bb.event.fire(bb.event.RecipeParsed(fn), d)
+
+def _create_variants(datastores, names, function):
+    def create_variant(name, orig_d, arg = None):
+        new_d = bb.data.createCopy(orig_d)
+        function(arg or name, new_d)
+        datastores[name] = new_d
+
+    for variant, variant_d in datastores.items():
+        for name in names:
+            if not variant:
+                # Based on main recipe
+                create_variant(name, variant_d)
+            else:
+                create_variant("%s-%s" % (variant, name), variant_d, name)
+
+def _expand_versions(versions):
+    def expand_one(version, start, end):
+        for i in xrange(start, end + 1):
+            ver = _bbversions_re.sub(str(i), version, 1)
+            yield ver
+
+    versions = iter(versions)
+    while True:
+        try:
+            version = next(versions)
+        except StopIteration:
+            break
+
+        range_ver = _bbversions_re.search(version)
+        if not range_ver:
+            yield version
+        else:
+            newversions = expand_one(version, int(range_ver.group("from")),
+                                     int(range_ver.group("to")))
+            versions = itertools.chain(newversions, versions)
+
+def multi_finalize(fn, d):
+    appends = (d.getVar("__BBAPPEND", True) or "").split()
+    for append in appends:
+        bb.msg.debug(2, bb.msg.domain.Parsing, "Appending .bbappend file " + append + " to " + fn)
+        bb.parse.BBHandler.handle(append, d, True)
+
+    safe_d = d
+    d = bb.data.createCopy(safe_d)
+    try:
+        finalize(fn, d)
+    except bb.parse.SkipPackage:
+        bb.data.setVar("__SKIPPED", True, d)
+    datastores = {"": safe_d}
+
+    versions = (d.getVar("BBVERSIONS", True) or "").split()
+    if versions:
+        pv = orig_pv = d.getVar("PV", True)
+        baseversions = {}
+
+        def verfunc(ver, d, pv_d = None):
+            if pv_d is None:
+                pv_d = d
+
+            overrides = d.getVar("OVERRIDES", True).split(":")
+            pv_d.setVar("PV", ver)
+            overrides.append(ver)
+            bpv = baseversions.get(ver) or orig_pv
+            pv_d.setVar("BPV", bpv)
+            overrides.append(bpv)
+            d.setVar("OVERRIDES", ":".join(overrides))
+
+        versions = list(_expand_versions(versions))
+        for pos, version in enumerate(list(versions)):
+            try:
+                pv, bpv = version.split(":", 2)
+            except ValueError:
+                pass
+            else:
+                versions[pos] = pv
+                baseversions[pv] = bpv
+
+        if pv in versions and not baseversions.get(pv):
+            versions.remove(pv)
+        else:
+            pv = versions.pop()
+
+            # This is necessary because our existing main datastore
+            # has already been finalized with the old PV, we need one
+            # that's been finalized with the new PV.
+            d = bb.data.createCopy(safe_d)
+            verfunc(pv, d, safe_d)
+            try:
+                finalize(fn, d)
+            except bb.parse.SkipPackage:
+                bb.data.setVar("__SKIPPED", True, d)
+
+        _create_variants(datastores, versions, verfunc)
+
+    extended = d.getVar("BBCLASSEXTEND", True) or ""
+    if extended:
+        pn = d.getVar("PN", True)
+        def extendfunc(name, d):
+            d.setVar("PN", "%s-%s" % (pn, name))
+            bb.parse.BBHandler.inherit([name], d)
+
+        safe_d.setVar("BBCLASSEXTEND", extended)
+        _create_variants(datastores, extended.split(), extendfunc)
+
+    for variant, variant_d in datastores.iteritems():
+        if variant:
+            try:
+                finalize(fn, variant_d, variant)
+            except bb.parse.SkipPackage:
+                bb.data.setVar("__SKIPPED", True, variant_d)
+
+    if len(datastores) > 1:
+        variants = filter(None, datastores.iterkeys())
+        safe_d.setVar("__VARIANTS", " ".join(variants))
+
+    datastores[""] = d
+    return datastores
--- a/bitbake/lib/bb/parse/parse_c/BBHandler.py
+++ b/bitbake/lib/bb/parse/parse_c/BBHandler.py
@@ -1,188 +0,0 @@
-# ex:ts=4:sw=4:sts=4:et
-# -*- tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*-
-"""class for handling .bb files (using a C++ parser)
-
-    Reads a .bb file and obtains its metadata (using a C++ parser)
-
-    Copyright (C) 2006 Tim Robert Ansell
-    Copyright (C) 2006 Holger Hans Peter Freyther
-
-    This program is free software; you can redistribute it and/or modify it under
-    the terms of the GNU General Public License as published by the Free Software
-    Foundation; either version 2 of the License, or (at your option) any later
-    version.
-
-    Permission is hereby granted, free of charge, to any person obtaining a copy
-    of this software and associated documentation files (the "Software"), to deal
-    in the Software without restriction, including without limitation the rights
-    to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-    copies of the Software, and to permit persons to whom the Software is
-    furnished to do so, subject to the following conditions:
-
-    The above copyright notice and this permission notice shall be included in all
-    copies or substantial portions of the Software.
-
-    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
-    SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-    DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-    OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR
-    THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-"""
-
-import os, sys
-
-# The Module we will use here
-import bb
-
-from bitbakec import parsefile
-
-#
-# This is the Python Part of the Native Parser Implementation.
-# We will only parse .bbclass, .inc and .bb files but no
-# configuration files.
-# supports, init and handle are the public methods used by
-# parser module
-#
-# The rest of the methods are internal implementation details.
-
-def _init(fn, d):
-    """
-    Initialize the data implementation with values of
-    the environment and data from the file.
-    """
-    pass
-
-#
-# public
-#
-def supports(fn, data):
-    return fn[-3:] == ".bb" or fn[-8:] == ".bbclass" or fn[-4:] == ".inc" or fn[-5:] == ".conf"
-
-def init(fn, data):
-    if not bb.data.getVar('TOPDIR', data):
-        bb.data.setVar('TOPDIR', os.getcwd(), data)
-    if not bb.data.getVar('BBPATH', data):
-        bb.data.setVar('BBPATH', os.path.join(sys.prefix, 'share', 'bitbake'), data)
-
-def handle_inherit(d):
-    """
-    Handle inheriting of classes. This will load all default classes.
-    It could be faster, it could detect infinite loops but this is todo
-    Also this delayed loading of bb.parse could impose a penalty
-    """
-    from bb.parse import handle
-
-    files = (data.getVar('INHERIT', d, True) or "").split()
-    if not "base" in i:
-        files[0:0] = ["base"]
-
-    __inherit_cache = data.getVar('__inherit_cache', d) or []
-    for f in files:
-        file = data.expand(f, d)
-        if file[0] != "/" and file[-8:] != ".bbclass":
-            file = os.path.join('classes', '%s.bbclass' % file)
-
-        if not file in __inherit_cache:
-            debug(2, "BB %s:%d: inheriting %s" % (fn, lineno, file))
-            __inherit_cache.append( file )
-
-            try:
-                handle(file, d, True)
-            except IOError:
-                print "Failed to inherit %s" % file
-    data.setVar('__inherit_cache', __inherit_cache, d)
-
-
-def handle(fn, d, include):
-    from bb import data, parse
-
-    (root, ext) = os.path.splitext(os.path.basename(fn))
-    base_name = "%s%s" % (root,ext)
-
-    # initialize with some data
-    init(fn,d)
-
-    # check if we include or are the beginning
-    oldfile = None
-    if include:
-        oldfile = d.getVar('FILE', False)
-        is_conf = False
-    elif ext == ".conf":
-        is_conf = True
-        data.inheritFromOS(d)
-
-    # find the file
-    if not os.path.isabs(fn):
-        abs_fn = bb.which(d.getVar('BBPATH', True), fn)
-    else:
-        abs_fn = fn
-
-    # check if the file exists
-    if not os.path.exists(abs_fn):
-        raise IOError("file '%(fn)s' not found" % locals() )
-
-    # now we know the file is around mark it as dep
-    if include:
-        parse.mark_dependency(d, abs_fn)
-
-    # manipulate the bbpath
-    if ext != ".bbclass" and ext != ".conf":
-        old_bb_path = data.getVar('BBPATH', d)
-        data.setVar('BBPATH', os.path.dirname(abs_fn) + (":%s" %old_bb_path) , d)
-
-    # handle INHERITS and base inherit
-    if ext != ".bbclass" and ext != ".conf":
-        data.setVar('FILE', fn, d)
-        handle_interit(d)
-
-    # now parse this file - by defering it to C++
-    parsefile(abs_fn, d, is_conf)
-
-    # Finish it up
-    if include == 0:
-        data.expandKeys(d)
-        data.update_data(d)
-        #### !!! XXX Finish it up by executing the anonfunc
-
-
-    # restore the original FILE
-    if oldfile:
-        d.setVar('FILE', oldfile)
-
-    # restore bbpath
-    if ext != ".bbclass" and ext != ".conf":
-        data.setVar('BBPATH', old_bb_path, d )
-
-
-    return d
-
-
-# Needed for BitBake files...
-__pkgsplit_cache__={}
-def vars_from_file(mypkg, d):
-    if not mypkg:
-        return (None, None, None)
-    if mypkg in __pkgsplit_cache__:
-        return __pkgsplit_cache__[mypkg]
-
-    myfile = os.path.splitext(os.path.basename(mypkg))
-    parts = myfile[0].split('_')
-    __pkgsplit_cache__[mypkg] = parts
-    exp = 3 - len(parts)
-    tmplist = []
-    while exp != 0:
-        exp -= 1
-        tmplist.append(None)
-    parts.extend(tmplist)
-    return parts
-
-
-
-
-# Inform bitbake that we are a parser
-# We need to define all three
-from bb.parse import handlers
-handlers.append( {'supports' : supports, 'handle': handle, 'init' : init})
-del handlers
--- a/bitbake/lib/bb/parse/parse_c/Makefile
+++ b/bitbake/lib/bb/parse/parse_c/Makefile
@@ -1,36 +0,0 @@
-
-buil: bitbakec.so
-	echo "Done"
-
-bitbakescanner.cc: bitbakescanner.l
-	flex -t bitbakescanner.l > bitbakescanner.cc
-
-bitbakeparser.cc: bitbakeparser.y python_output.h 
-	lemon bitbakeparser.y
-	mv bitbakeparser.c bitbakeparser.cc
-
-bitbakec.c: bitbakec.pyx
-	pyrexc bitbakec.pyx
-
-bitbakec-processed.c: bitbakec.c
-	cat bitbakec.c | sed -e"s/__pyx_f_8bitbakec_//" > bitbakec-processed.c
-
-bitbakec.o: bitbakec-processed.c
-	gcc -c bitbakec-processed.c -o bitbakec.o -fPIC -I/usr/include/python2.4
-
-bitbakeparser.o: bitbakeparser.cc 
-	g++ -c bitbakeparser.cc -fPIC -I/usr/include/python2.4
-
-bitbakescanner.o: bitbakescanner.cc
-	g++ -c bitbakescanner.cc -fPIC -I/usr/include/python2.4
-
-bitbakec.so: bitbakec.o bitbakeparser.o bitbakescanner.o
-	g++ -shared -fPIC bitbakeparser.o bitbakescanner.o bitbakec.o -o bitbakec.so
-
-clean:
-	rm -f *.out
-	rm -f *.cc
-	rm -f bitbakec.c
-	rm -f bitbakec-processed.c
-	rm -f *.o
-	rm -f *.so
--- a/bitbake/lib/bb/parse/parse_c/README.build
+++ b/bitbake/lib/bb/parse/parse_c/README.build
@@ -1,12 +0,0 @@
-To ease portability (lemon, flex, etc) we keep the
-result of flex and lemon in the source code. We agree
-to not manually change the scanner and parser.
-
-
-
-How we create the files:
-   flex -t bitbakescanner.l > bitbakescanner.cc
-   lemon bitbakeparser.y
-   mv bitbakeparser.c bitbakeparser.cc
-
-Now manually create two files
--- a/bitbake/lib/bb/parse/parse_c/init.py
+++ b/bitbake/lib/bb/parse/parse_c/init.py
@@ -1,28 +0,0 @@
-# ex:ts=4:sw=4:sts=4:et
-# -*- tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*-
-#
-# Copyright (C) 2006 Holger Hans Peter Freyther
-#
-# Permission is hereby granted, free of charge, to any person obtaining a copy
-# of this software and associated documentation files (the "Software"), to deal
-# in the Software without restriction, including without limitation the rights
-# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-# copies of the Software, and to permit persons to whom the Software is
-# furnished to do so, subject to the following conditions:
-#
-# The above copyright notice and this permission notice shall be included in all
-# copies or substantial portions of the Software.
-#
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
-# SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-# DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-# OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR
-# THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-#
-
-__version__ = '0.1'
-__all__     = [ 'BBHandler' ]
-
-import BBHandler
--- a/bitbake/lib/bb/parse/parse_c/bitbakec.pyx
+++ b/bitbake/lib/bb/parse/parse_c/bitbakec.pyx
@@ -1,253 +0,0 @@
-# ex:ts=4:sw=4:sts=4:et
-# -*- tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*-
-
-cdef extern from "stdio.h":
-    ctypedef int FILE
-    FILE *fopen(char*, char*)
-    int fclose(FILE *fp)
-
-cdef extern from "string.h":
-    int strlen(char*)
-
-cdef extern from "lexerc.h":
-    ctypedef struct lex_t:
-        void* parser
-        void* scanner
-        char* name
-        FILE* file
-        int config
-        void* data
-
-    int lineError
-    int errorParse
-
-    cdef extern int parse(FILE*, char*, object, int)
-
-def parsefile(object file, object data, object config):
-    #print "parsefile: 1", file, data
-
-    # Open the file
-    cdef FILE* f
-
-    f = fopen(file, "r")
-    #print "parsefile: 2 opening file"
-    if (f == NULL):
-        raise IOError("No such file %s." % file)
-
-    #print "parsefile: 3 parse"
-    parse(f, file, data, config)
-
-    # Close the file
-    fclose(f)
-
-
-cdef public void e_assign(lex_t* container, char* key, char* what):
-    #print "e_assign", key, what
-    if what == NULL:
-        print "FUTURE Warning empty string: use \"\""
-        what = ""
-
-    d = <object>container.data
-    d.setVar(key, what)
-
-cdef public void e_export(lex_t* c, char* what):
-    #print "e_export", what
-    #exp:
-    # bb.data.setVarFlag(key, "export", 1, data)
-    d = <object>c.data
-    d.setVarFlag(what, "export", 1)
-
-cdef public void e_immediate(lex_t* c, char* key, char* what):
-    #print "e_immediate", key, what
-    #colon:
-    # val = bb.data.expand(groupd["value"], data)
-    d = <object>c.data
-    d.setVar(key, d.expand(what,d))
-
-cdef public void e_cond(lex_t* c, char* key, char* what):
-    #print "e_cond", key, what
-    #ques:
-    # val = bb.data.getVar(key, data)
-    # if val == None:    
-    #    val = groupd["value"]
-    if what == NULL:
-        print "FUTURE warning: Use \"\" for", key
-        what = ""
-
-    d = <object>c.data
-    d.setVar(key, (d.getVar(key,False) or what))
-
-cdef public void e_prepend(lex_t* c, char* key, char* what):
-    #print "e_prepend", key, what
-    #prepend:
-    # val = "%s %s" % (groupd["value"], (bb.data.getVar(key, data) or ""))
-    d = <object>c.data
-    d.setVar(key, what + " " + (d.getVar(key,0) or ""))
-
-cdef public void e_append(lex_t* c, char* key, char* what):
-    #print "e_append", key, what
-    #append:
-    # val = "%s %s" % ((bb.data.getVar(key, data) or ""), groupd["value"])
-    d = <object>c.data
-    d.setVar(key, (d.getVar(key,0) or "") + " " + what)
-
-cdef public void e_precat(lex_t* c, char* key, char* what):
-    #print "e_precat", key, what
-    #predot:
-    # val = "%s%s" % (groupd["value"], (bb.data.getVar(key, data) or ""))
-    d = <object>c.data
-    d.setVar(key, what + (d.getVar(key,0) or ""))
-
-cdef public void e_postcat(lex_t* c, char* key, char* what):
-    #print "e_postcat", key, what
-    #postdot:
-    # val = "%s%s" % ((bb.data.getVar(key, data) or ""), groupd["value"])
-    d = <object>c.data
-    d.setVar(key, (d.getVar(key,0) or "") + what)
-
-cdef public int e_addtask(lex_t* c, char* name, char* before, char* after) except -1:
-    #print "e_addtask", name
-    # func = m.group("func")
-    # before = m.group("before")
-    # after = m.group("after")
-    # if func is None:
-    #     return
-    # var = "do_" + func
-    #
-    # data.setVarFlag(var, "task", 1, d)
-    #
-    # if after is not None:
-    # #  set up deps for function
-    #     data.setVarFlag(var, "deps", after.split(), d)
-    # if before is not None:
-    # #   set up things that depend on this func
-    #     data.setVarFlag(var, "postdeps", before.split(), d)
-    # return
-
-    if c.config == 1:
-        from bb.parse import ParseError
-        raise ParseError("No tasks allowed in config files")
-        return -1
-
-    d = <object>c.data
-    do = "do_%s" % name
-    d.setVarFlag(do, "task", 1)
-
-    if before != NULL and strlen(before) > 0:
-        #print "Before", before
-        d.setVarFlag(do, "postdeps", ("%s" % before).split())
-    if after  != NULL and strlen(after) > 0:
-        #print "After", after
-        d.setVarFlag(do, "deps", ("%s" % after).split())
-
-    return 0
-
-cdef public int e_addhandler(lex_t* c, char* h) except -1:
-    #print "e_addhandler", h
-    # data.setVarFlag(h, "handler", 1, d)
-    if c.config == 1:
-        from bb.parse import ParseError
-        raise ParseError("No handlers allowed in config files")
-        return -1
-
-    d = <object>c.data
-    d.setVarFlag(h, "handler", 1)
-    return 0
-
-cdef public int e_export_func(lex_t* c, char* function) except -1:
-    #print "e_export_func", function
-    if c.config == 1:
-        from bb.parse import ParseError
-        raise ParseError("No functions allowed in config files")
-        return -1
-
-    return 0
-
-cdef public int e_inherit(lex_t* c, char* file) except -1:
-    #print "e_inherit", file
-
-    if c.config == 1:
-        from bb.parse import ParseError
-        raise ParseError("No inherits allowed in config files")
-        return -1
-
-    return 0
-
-cdef public void e_include(lex_t* c, char* file):
-    from bb.parse import handle
-    d = <object>c.data
-
-    try:
-        handle(d.expand(file,d), d, True)
-    except IOError:
-        print "Could not include file", file
-
-
-cdef public int e_require(lex_t* c, char* file) except -1:
-    #print "e_require", file
-    from bb.parse import handle
-    d = <object>c.data
-
-    try:
-        handle(d.expand(file,d), d, True)
-    except IOError:
-        print "ParseError", file
-        from bb.parse import ParseError
-        raise ParseError("Could not include required file %s" % file)
-        return -1
-
-    return 0
-
-cdef public int e_proc(lex_t* c, char* key, char* what) except -1:
-    #print "e_proc", key, what
-    if c.config == 1:
-        from bb.parse import ParseError
-        raise ParseError("No inherits allowed in config files")
-        return -1
-
-    return 0
-
-cdef public int e_proc_python(lex_t* c, char* key, char* what) except -1:
-    #print "e_proc_python"
-    if c.config == 1:
-        from bb.parse import ParseError
-        raise ParseError("No pythin allowed in config files")
-        return -1
-
-    if key != NULL:
-        pass
-        #print "Key", key
-    if what != NULL:
-        pass
-        #print "What", what
-
-    return 0
-
-cdef public int e_proc_fakeroot(lex_t* c, char* key, char* what) except -1:
-    #print "e_fakeroot", key, what
-
-    if c.config == 1:
-        from bb.parse import ParseError
-        raise ParseError("No fakeroot allowed in config files")
-        return -1
-
-    return 0
-
-cdef public int e_def(lex_t* c, char* a, char* b, char* d) except -1:
-    #print "e_def", a, b, d
-
-    if c.config == 1:
-        from bb.parse import ParseError
-        raise ParseError("No defs allowed in config files")
-        return -1
-
-    return 0
-
-cdef public int e_parse_error(lex_t* c) except -1:
-    print "e_parse_error", c.name, "line:", lineError, "parse:", errorParse
-
-
-    from bb.parse import ParseError
-    raise ParseError("There was an parse error, sorry unable to give more information at the current time. File: %s Line: %d" % (c.name,lineError) )
-    return -1
-
--- a/bitbake/lib/bb/parse/parse_c/bitbakeparser.cc
+++ b/bitbake/lib/bb/parse/parse_c/bitbakeparser.cc
--- a/bitbake/lib/bb/parse/parse_c/bitbakeparser.h
+++ b/bitbake/lib/bb/parse/parse_c/bitbakeparser.h
@@ -1,29 +0,0 @@
-#define T_SYMBOL                          1
-#define T_VARIABLE                        2
-#define T_EXPORT                          3
-#define T_OP_ASSIGN                       4
-#define T_STRING                          5
-#define T_OP_PREDOT                       6
-#define T_OP_POSTDOT                      7
-#define T_OP_IMMEDIATE                    8
-#define T_OP_COND                         9
-#define T_OP_PREPEND                     10
-#define T_OP_APPEND                      11
-#define T_TSYMBOL                        12
-#define T_BEFORE                         13
-#define T_AFTER                          14
-#define T_ADDTASK                        15
-#define T_ADDHANDLER                     16
-#define T_FSYMBOL                        17
-#define T_EXPORT_FUNC                    18
-#define T_ISYMBOL                        19
-#define T_INHERIT                        20
-#define T_INCLUDE                        21
-#define T_REQUIRE                        22
-#define T_PROC_BODY                      23
-#define T_PROC_OPEN                      24
-#define T_PROC_CLOSE                     25
-#define T_PYTHON                         26
-#define T_FAKEROOT                       27
-#define T_DEF_BODY                       28
-#define T_DEF_ARGS                       29
--- a/bitbake/lib/bb/parse/parse_c/bitbakeparser.y
+++ b/bitbake/lib/bb/parse/parse_c/bitbakeparser.y
@@ -1,179 +0,0 @@
-/* bbp.lemon 
-
-   written by Marc Singer
-   6 January 2005
-
-   This program is free software; you can redistribute it and/or
-   modify it under the terms of the GNU General Public License as
-   published by the Free Software Foundation; either version 2 of the
-   License, or (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful, but
-   WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-   General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with this program; if not, write to the Free Software
-   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
-   USA.
-
-   DESCRIPTION
-   -----------
-
-   lemon parser specification file for a BitBake input file parser.
-
-   Most of the interesting shenanigans are done in the lexer.  The
-   BitBake grammar is not regular.  In order to emit tokens that
-   the parser can properly interpret in LALR fashion, the lexer
-   manages the interpretation state.  This is why there are ISYMBOLs,
-   SYMBOLS, and TSYMBOLS.
-
-   This parser was developed by reading the limited available
-   documentation for BitBake and by analyzing the available BB files.
-   There is no assertion of correctness to be made about this parser.
-
-*/
-
-%token_type {token_t}
-%name bbparse
-%token_prefix   T_
-%extra_argument  {lex_t* lex}
-
-%include {
-#include "token.h"
-#include "lexer.h"
-#include "python_output.h"
-}
-
-
-%token_destructor { $$.release_this (); }
-
-%syntax_error     { e_parse_error( lex ); }
-
-program ::= statements.
-
-statements ::= statements statement.
-statements ::= .
-
-variable(r) ::= SYMBOL(s).
-        { r.assignString( (char*)s.string() );
-          s.assignString( 0 );
-          s.release_this(); }
-variable(r) ::= VARIABLE(v).
-        {
-          r.assignString( (char*)v.string() );
-          v.assignString( 0 );
-          v.release_this(); }
-
-statement ::= EXPORT variable(s) OP_ASSIGN STRING(v).
-        { e_assign( lex, s.string(), v.string() );
-          e_export( lex, s.string() );
-          s.release_this(); v.release_this(); }
-statement ::= EXPORT variable(s) OP_PREDOT STRING(v).
-        { e_precat( lex, s.string(), v.string() );
-          e_export( lex, s.string() );
-          s.release_this(); v.release_this(); }
-statement ::= EXPORT variable(s) OP_POSTDOT STRING(v).
-        { e_postcat( lex, s.string(), v.string() );
-          e_export( lex, s.string() );
-          s.release_this(); v.release_this(); }
-statement ::= EXPORT variable(s) OP_IMMEDIATE STRING(v).
-        { e_immediate ( lex, s.string(), v.string() );
-          e_export( lex, s.string() );
-          s.release_this(); v.release_this(); }
-statement ::= EXPORT variable(s) OP_COND STRING(v).
-        { e_cond( lex, s.string(), v.string() );
-          s.release_this(); v.release_this(); }
-
-statement ::= variable(s) OP_ASSIGN STRING(v).
-        { e_assign( lex, s.string(), v.string() );
-          s.release_this(); v.release_this(); }
-statement ::= variable(s) OP_PREDOT STRING(v).
-        { e_precat( lex, s.string(), v.string() );
-          s.release_this(); v.release_this(); }
-statement ::= variable(s) OP_POSTDOT STRING(v).
-        { e_postcat( lex, s.string(), v.string() );
-          s.release_this(); v.release_this(); }
-statement ::= variable(s) OP_PREPEND STRING(v).
-        { e_prepend( lex, s.string(), v.string() );
-          s.release_this(); v.release_this(); }
-statement ::= variable(s) OP_APPEND STRING(v).
-        { e_append( lex, s.string() , v.string() );
-          s.release_this(); v.release_this(); }
-statement ::= variable(s) OP_IMMEDIATE STRING(v).
-        { e_immediate( lex, s.string(), v.string() );
-          s.release_this(); v.release_this(); }
-statement ::= variable(s) OP_COND STRING(v).
-        { e_cond( lex, s.string(), v.string() );
-          s.release_this(); v.release_this(); }
-
-task ::= TSYMBOL(t) BEFORE TSYMBOL(b) AFTER  TSYMBOL(a).
-        { e_addtask( lex, t.string(), b.string(), a.string() );
-          t.release_this(); b.release_this(); a.release_this(); }
-task ::= TSYMBOL(t) AFTER  TSYMBOL(a) BEFORE TSYMBOL(b).
-        { e_addtask( lex, t.string(), b.string(), a.string());
-          t.release_this(); a.release_this(); b.release_this(); }
-task ::= TSYMBOL(t).
-        { e_addtask( lex, t.string(), NULL, NULL);
-          t.release_this();}
-task ::= TSYMBOL(t) BEFORE TSYMBOL(b).
-        { e_addtask( lex, t.string(), b.string(), NULL);
-          t.release_this(); b.release_this(); }
-task ::= TSYMBOL(t) AFTER  TSYMBOL(a).
-        { e_addtask( lex, t.string(), NULL, a.string());
-          t.release_this(); a.release_this(); }
-tasks ::= tasks task.
-tasks ::= task.
-statement ::= ADDTASK tasks.
-
-statement ::= ADDHANDLER SYMBOL(s).
-        { e_addhandler( lex, s.string()); s.release_this (); }
-
-func ::= FSYMBOL(f). { e_export_func( lex, f.string()); f.release_this(); }
-funcs ::= funcs func.
-funcs ::= func.
-statement ::= EXPORT_FUNC funcs.
-
-inherit ::= ISYMBOL(i). { e_inherit( lex, i.string() ); i.release_this (); }
-inherits ::= inherits inherit.
-inherits ::= inherit.
-statement ::= INHERIT inherits.
-
-statement ::= INCLUDE ISYMBOL(i).
-        { e_include( lex, i.string() ); i.release_this(); }
-
-statement ::= REQUIRE ISYMBOL(i).
-        { e_require( lex, i.string() ); i.release_this(); }
-
-proc_body(r) ::= proc_body(l) PROC_BODY(b).
-        { /* concatenate body lines */
-          r.assignString( token_t::concatString(l.string(), b.string()) );
-          l.release_this ();
-          b.release_this ();
-        }
-proc_body(b) ::= . { b.assignString(0); }
-statement ::= variable(p) PROC_OPEN proc_body(b) PROC_CLOSE.
-        { e_proc( lex, p.string(), b.string() );
-          p.release_this(); b.release_this(); }
-statement ::= PYTHON SYMBOL(p) PROC_OPEN proc_body(b) PROC_CLOSE.
-        { e_proc_python ( lex, p.string(), b.string() );
-          p.release_this(); b.release_this(); }
-statement ::= PYTHON PROC_OPEN proc_body(b) PROC_CLOSE.
-        { e_proc_python( lex, NULL, b.string());
-          b.release_this (); }
-
-statement ::= FAKEROOT SYMBOL(p) PROC_OPEN proc_body(b) PROC_CLOSE.
-        { e_proc_fakeroot( lex, p.string(), b.string() );
-          p.release_this (); b.release_this (); }
-
-def_body(r) ::= def_body(l) DEF_BODY(b).
-        { /* concatenate body lines */
-          r.assignString( token_t::concatString(l.string(), b.string()) );
-          l.release_this (); b.release_this ();
-        }
-def_body(b) ::= . { b.assignString( 0 ); }
-statement ::= SYMBOL(p) DEF_ARGS(a) def_body(b).
-        { e_def( lex, p.string(), a.string(), b.string());
-          p.release_this(); a.release_this(); b.release_this(); }
-
--- a/bitbake/lib/bb/parse/parse_c/bitbakescanner.cc
+++ b/bitbake/lib/bb/parse/parse_c/bitbakescanner.cc
--- a/bitbake/lib/bb/parse/parse_c/bitbakescanner.l
+++ b/bitbake/lib/bb/parse/parse_c/bitbakescanner.l
@@ -1,319 +0,0 @@
-/* bbf.flex 
-
-   written by Marc Singer
-   6 January 2005
-
-   This program is free software; you can redistribute it and/or
-   modify it under the terms of the GNU General Public License as
-   published by the Free Software Foundation; either version 2 of the
-   License, or (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful, but
-   WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-   General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with this program; if not, write to the Free Software
-   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
-   USA.
-
-   DESCRIPTION
-   -----------
-
-   flex lexer specification for a BitBake input file parser.
-
-   Unfortunately, flex doesn't welcome comments within the rule sets.
-   I say unfortunately because this lexer is unreasonably complex and
-   comments would make the code much easier to comprehend.
-
-   The BitBake grammar is not regular.  In order to interpret all
-   of the available input files, the lexer maintains much state as it
-   parses.  There are places where this lexer will emit tokens that
-   are invalid.  The parser will tend to catch these. 
-
-   The lexer requires C++ at the moment.  The only reason for this has
-   to do with a very small amount of managed state.  Producing a C
-   lexer should be a reasonably easy task as long as the %reentrant
-   option is used.
-
-
-   NOTES
-   -----
-
-   o RVALUES.  There are three kinds of RVALUES.  There are unquoted
-     values, double quote enclosed strings, and single quote 
-     strings.  Quoted strings may contain unescaped quotes (of either
-     type), *and* any type may span more than one line by using a
-     continuation '\' at the end of the line.  This requires us to
-     recognize all types of values with a single expression.
-     Moreover, the only reason to quote a value is to include
-     trailing or leading whitespace.  Whitespace within a value is
-     preserved, ugh.
-
-   o CLASSES.  C_ patterns define classes.  Classes ought not include
-     a repitition operator, instead letting the reference to the class
-     define the repitition count.
-
-     C_SS - symbol start
-     C_SB - symbol body
-     C_SP - whitespace
-
-*/
-
-%option never-interactive
-%option yylineno
-%option noyywrap
-%option reentrant stack
-
-
-%{
-
-#include "token.h"
-#include "lexer.h"
-#include "bitbakeparser.h"
-#include <ctype.h>
-
-extern void *bbparseAlloc(void *(*mallocProc)(size_t));
-extern void bbparseFree(void *p, void (*freeProc)(void*));
-extern void *bbparseAlloc(void *(*mallocProc)(size_t));
-extern void *bbparse(void*, int, token_t, lex_t*);
-extern void bbparseTrace(FILE *TraceFILE, char *zTracePrompt);
-
-//static const char* rgbInput;
-//static size_t cbInput;
-
-extern "C" {
-
-int lineError;
-int errorParse;
-
-enum {
-  errorNone = 0,
-  errorUnexpectedInput,
-  errorUnsupportedFeature,
-};
-
-}
-
-#define YY_EXTRA_TYPE lex_t*
-
-	/* Read from buffer */
-#define YY_INPUT(buf,result,max_size) \
- { yyextra->input(buf, &result, max_size); }
-
-//#define YY_DECL static size_t yylex ()
-
-#define ERROR(e) \
-  do { lineError = yylineno; errorParse = e; yyterminate (); } while (0)
-
-static const char* fixup_escapes (const char* sz);
-
-%}
-
-
-C_SP            [ \t]
-COMMENT         #.*\n
-OP_ASSIGN       "="
-OP_PREDOT       ".="
-OP_POSTDOT      "=."
-OP_IMMEDIATE    ":="
-OP_PREPEND      "=+"
-OP_APPEND       "+="
-OP_COND         "?="
-B_OPEN          "{"
-B_CLOSE         "}"
-
-K_ADDTASK       "addtask"
-K_ADDHANDLER    "addhandler"
-K_AFTER         "after"
-K_BEFORE        "before"
-K_DEF           "def"
-K_INCLUDE       "include"
-K_REQUIRE       "require"
-K_INHERIT       "inherit"
-K_PYTHON        "python"
-K_FAKEROOT      "fakeroot"
-K_EXPORT        "export"
-K_EXPORT_FUNC   "EXPORT_FUNCTIONS"
-
-STRING          \"([^\n\r]|"\\\n")*\"
-SSTRING         \'([^\n\r]|"\\\n")*\'
-VALUE           ([^'" \t\n])|([^'" \t\n]([^\n]|(\\\n))*[^'" \t\n])
-
-C_SS            [a-zA-Z_]
-C_SB            [a-zA-Z0-9_+-./]
-REF             $\{{C_SS}{C_SB}*\}
-SYMBOL          {C_SS}{C_SB}*
-VARIABLE        $?{C_SS}({C_SB}*|{REF})*(\[[a-zA-Z0-9_]*\])?
-FILENAME        ([a-zA-Z_./]|{REF})(([-+a-zA-Z0-9_./]*)|{REF})*
-
-PROC            \({C_SP}*\)
-
-%s S_DEF
-%s S_DEF_ARGS
-%s S_DEF_BODY
-%s S_FUNC
-%s S_INCLUDE
-%s S_INHERIT
-%s S_REQUIRE
-%s S_PROC
-%s S_RVALUE
-%s S_TASK
-
-%%
-
-{OP_APPEND}                     { BEGIN S_RVALUE;
-                                  yyextra->accept (T_OP_APPEND); }
-{OP_PREPEND}                    { BEGIN S_RVALUE;
-                                  yyextra->accept (T_OP_PREPEND); }
-{OP_IMMEDIATE}                  { BEGIN S_RVALUE;
-                                  yyextra->accept (T_OP_IMMEDIATE); }
-{OP_ASSIGN}                     { BEGIN S_RVALUE;
-                                  yyextra->accept (T_OP_ASSIGN); }
-{OP_PREDOT}                     { BEGIN S_RVALUE;
-                                  yyextra->accept (T_OP_PREDOT); }
-{OP_POSTDOT}                    { BEGIN S_RVALUE;
-                                  yyextra->accept (T_OP_POSTDOT); }
-{OP_COND}                       { BEGIN S_RVALUE;
-                                  yyextra->accept (T_OP_COND); }
-
-<S_RVALUE>\\\n{C_SP}*           {  }
-<S_RVALUE>{STRING}              { BEGIN INITIAL;
-                                  size_t cb = yyleng;
-                                  while (cb && isspace (yytext[cb - 1]))
-                                      --cb;
-                                  yytext[cb - 1] = 0;
-                                  yyextra->accept (T_STRING, yytext + 1); }
-<S_RVALUE>{SSTRING}             { BEGIN INITIAL;
-                                  size_t cb = yyleng;
-                                  while (cb && isspace (yytext[cb - 1]))
-                                      --cb;
-                                  yytext[cb - 1] = 0;
-                                  yyextra->accept (T_STRING, yytext + 1); }
-
-<S_RVALUE>{VALUE}               { ERROR (errorUnexpectedInput);  }
-<S_RVALUE>{C_SP}*\n+            { BEGIN INITIAL;
-                                  yyextra->accept (T_STRING, NULL); }
-
-{K_INCLUDE}                     { BEGIN S_INCLUDE;
-                                  yyextra->accept (T_INCLUDE); }
-{K_REQUIRE}                     { BEGIN S_REQUIRE;
-                                  yyextra->accept (T_REQUIRE); }
-{K_INHERIT}                     { BEGIN S_INHERIT;
-                                  yyextra->accept (T_INHERIT); }
-{K_ADDTASK}                     { BEGIN S_TASK;
-                                  yyextra->accept (T_ADDTASK); }
-{K_ADDHANDLER}                  { yyextra->accept (T_ADDHANDLER); }
-{K_EXPORT_FUNC}                 { BEGIN S_FUNC;
-                                  yyextra->accept (T_EXPORT_FUNC); }
-<S_TASK>{K_BEFORE}              { yyextra->accept (T_BEFORE); }
-<S_TASK>{K_AFTER}               { yyextra->accept (T_AFTER); }
-<INITIAL>{K_EXPORT}             { yyextra->accept (T_EXPORT); }
-
-<INITIAL>{K_FAKEROOT}           { yyextra->accept (T_FAKEROOT); }
-<INITIAL>{K_PYTHON}             { yyextra->accept (T_PYTHON); }
-{PROC}{C_SP}*{B_OPEN}{C_SP}*\n*  { BEGIN S_PROC;
-                                  yyextra->accept (T_PROC_OPEN); }
-<S_PROC>{B_CLOSE}{C_SP}*\n*      { BEGIN INITIAL;
-                                  yyextra->accept (T_PROC_CLOSE); }
-<S_PROC>([^}][^\n]*)?\n*        { yyextra->accept (T_PROC_BODY, yytext); }
-
-{K_DEF}                         { BEGIN S_DEF; }
-<S_DEF>{SYMBOL}                 { BEGIN S_DEF_ARGS;
-                                  yyextra->accept (T_SYMBOL, yytext); }
-<S_DEF_ARGS>[^\n:]*:            { yyextra->accept (T_DEF_ARGS, yytext); }
-<S_DEF_ARGS>{C_SP}*\n           { BEGIN S_DEF_BODY; }
-<S_DEF_BODY>{C_SP}+[^\n]*\n     { yyextra->accept (T_DEF_BODY, yytext); }
-<S_DEF_BODY>\n                  { yyextra->accept (T_DEF_BODY, yytext); }
-<S_DEF_BODY>.                   { BEGIN INITIAL; unput (yytext[0]); }
-
-{COMMENT}                       { }
-
-<INITIAL>{SYMBOL}               { yyextra->accept (T_SYMBOL, yytext); }
-<INITIAL>{VARIABLE}             { yyextra->accept (T_VARIABLE, yytext); }
-
-<S_TASK>{SYMBOL}                { yyextra->accept (T_TSYMBOL, yytext); }
-<S_FUNC>{SYMBOL}                { yyextra->accept (T_FSYMBOL, yytext); }
-<S_INHERIT>{SYMBOL}             { yyextra->accept (T_ISYMBOL, yytext); }
-<S_INCLUDE>{FILENAME}           { BEGIN INITIAL;
-                                  yyextra->accept (T_ISYMBOL, yytext); }
-<S_REQUIRE>{FILENAME}           { BEGIN INITIAL;
-                                  yyextra->accept (T_ISYMBOL, yytext); }
-<S_TASK>\n                      { BEGIN INITIAL; }
-<S_FUNC>\n                      { BEGIN INITIAL; }
-<S_INHERIT>\n                   { BEGIN INITIAL; }
-
-[ \t\r\n]                       /* Insignificant whitespace */
-
-.                               { ERROR (errorUnexpectedInput); }
-
-                                /* Check for premature termination */
-<<EOF>>                         { return T_EOF; }
-
-%%
-
-void lex_t::accept (int token, const char* sz) 
-{
-    token_t t;
-    memset (&t, 0, sizeof (t));
-    t.copyString(sz);
-
-    /* tell lemon to parse the token */
-    parse (parser, token, t, this);
-}
-
-void lex_t::input (char *buf, int *result, int max_size)
-{
-    /* printf("lex_t::input %p %d\n", buf, max_size); */
-    *result = fread(buf, 1, max_size, file);
-    /* printf("lex_t::input result %d\n", *result); */
-}
-
-int lex_t::line ()const
-{
-    /* printf("lex_t::line\n"); */
-    return yyget_lineno (scanner);
-}
-
-
-extern "C" {
-
-    void parse (FILE* file, char* name, PyObject* data, int config)
-    {
-        /* printf("parse bbparseAlloc\n"); */
-        void* parser = bbparseAlloc (malloc);
-        yyscan_t scanner;
-        lex_t lex;
-
-        /* printf("parse yylex_init\n"); */
-        yylex_init (&scanner);
-
-        lex.parser = parser;
-        lex.scanner = scanner;
-        lex.file = file;
-        lex.name = name;
-        lex.data = data;
-        lex.config = config;
-        lex.parse = bbparse;
-        /*printf("parse yyset_extra\n"); */
-        yyset_extra (&lex, scanner);
-
-        /* printf("parse yylex\n"); */
-        int result = yylex (scanner);
-
-        /* printf("parse result %d\n", result); */
-
-        lex.accept (0);
-        /* printf("parse lex.accept\n"); */
-        bbparseTrace (NULL, NULL);
-        /* printf("parse bbparseTrace\n"); */
-
-        if (result != T_EOF)
-           printf ("premature end of file\n");
-
-        yylex_destroy (scanner);
-        bbparseFree (parser, free);
-    }
-
-}
--- a/bitbake/lib/bb/parse/parse_c/lexer.h
+++ b/bitbake/lib/bb/parse/parse_c/lexer.h
@@ -1,48 +0,0 @@
-/*
-Copyright (C) 2005 Holger Hans Peter Freyther
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
-SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR
-THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-*/
-
-#ifndef LEXER_H
-#define LEXER_H
-
-#include "Python.h"
-
-extern "C" {
-
-struct lex_t {
-    void* parser;
-    void* scanner;
-    FILE* file;
-    char *name;
-    PyObject *data;
-    int config;
-
-    void* (*parse)(void*, int, token_t, lex_t*);
-
-    void accept(int token, const char* sz = NULL);
-    void input(char *buf, int *result, int max_size);
-    int  line()const;
-};
-
-}
-
-#endif
--- a/bitbake/lib/bb/parse/parse_c/lexerc.h
+++ b/bitbake/lib/bb/parse/parse_c/lexerc.h
@@ -1,19 +0,0 @@
-
-#ifndef LEXERC_H
-#define LEXERC_H
-
-#include <stdio.h>
-
-extern int lineError;
-extern int errorParse;
-
-typedef struct {
-    void *parser;
-    void *scanner;
-    FILE *file;
-    char *name;
-    PyObject *data;
-    int config;
-} lex_t;
-
-#endif
--- a/bitbake/lib/bb/parse/parse_c/python_output.h
+++ b/bitbake/lib/bb/parse/parse_c/python_output.h
@@ -1,56 +0,0 @@
-#ifndef PYTHON_OUTPUT_H
-#define PYTHON_OUTPUT_H
-/*
-Copyright (C) 2006 Holger Hans Peter Freyther
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
-SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR
-THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-This is the glue:
-    It will be called from the lemon grammar and will call into
-    python to set certain things.
-
-*/
-
-extern "C" {
-
-struct lex_t;
-
-extern void e_assign(lex_t*, const char*, const char*);
-extern void e_export(lex_t*, const char*);
-extern void e_immediate(lex_t*, const char*, const char*);
-extern void e_cond(lex_t*, const char*, const char*);
-extern void e_prepend(lex_t*, const char*, const char*);
-extern void e_append(lex_t*, const char*, const char*);
-extern void e_precat(lex_t*, const char*, const char*);
-extern void e_postcat(lex_t*, const char*, const char*);
-
-extern void e_addtask(lex_t*, const char*, const char*, const char*);
-extern void e_addhandler(lex_t*,const char*);
-extern void e_export_func(lex_t*, const char*);
-extern void e_inherit(lex_t*, const char*);
-extern void e_include(lex_t*, const char*);
-extern void e_require(lex_t*, const char*);
-extern void e_proc(lex_t*, const char*, const char*);
-extern void e_proc_python(lex_t*, const char*, const char*);
-extern void e_proc_fakeroot(lex_t*, const char*, const char*);
-extern void e_def(lex_t*, const char*, const char*, const char*);
-extern void e_parse_error(lex_t*);
-
-}
-#endif // PYTHON_OUTPUT_H
--- a/bitbake/lib/bb/parse/parse_c/token.h
+++ b/bitbake/lib/bb/parse/parse_c/token.h
@@ -1,96 +0,0 @@
-/*
-Copyright (C) 2005 Holger Hans Peter Freyther
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
-SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR
-THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-*/
-
-#ifndef TOKEN_H
-#define TOKEN_H
-
-#include <ctype.h>
-#include <string.h>
-
-#define PURE_METHOD
-
-
-/**
- * Special Value for End Of File Handling. We set it to
- * 1001 so we can have up to 1000 Terminal Symbols on
- * grammar. Currenlty we have around 20
- */
-#define T_EOF    1001
-
-struct token_t {
-    const char* string()const PURE_METHOD;
-
-    static char* concatString(const char* l, const char* r);
-    void assignString(char* str);
-    void copyString(const char* str);
-
-    void release_this();
-
-private:
-    char  *m_string;
-    size_t m_stringLen;
-};
-
-inline const char* token_t::string()const
-{
-    return m_string;
-}
-
-/*
- * append str to the current string
- */
-inline char* token_t::concatString(const char* l, const char* r)
-{
-    size_t cb = (l ? strlen (l) : 0) + strlen (r) + 1;
-    char *r_sz = new char[cb];
-    *r_sz = 0;
-
-    if (l)
-        strcat (r_sz, l);
-    strcat (r_sz, r);
-
-    return r_sz;
-}
-
-inline void token_t::assignString(char* str)
-{
-    m_string = str;
-    m_stringLen = str ? strlen(str) : 0;
-}
-
-inline void token_t::copyString(const char* str)
-{
-    if( str ) {
-        m_stringLen = strlen(str);
-        m_string = new char[m_stringLen+1];
-        strcpy(m_string, str);
-    }
-}
-
-inline void token_t::release_this()
-{
-    delete m_string;
-    m_string = 0;
-}
-
-#endif
--- a/bitbake/lib/bb/parse/parse_py/BBHandler.py
+++ b/bitbake/lib/bb/parse/parse_py/BBHandler.py
@@ -11,7 +11,7 @@

 #  Copyright (C) 2003, 2004  Chris Larson
 #  Copyright (C) 2003, 2004  Phil Blundell
-#   
+#
 # This program is free software; you can redistribute it and/or modify
 # it under the terms of the GNU General Public License version 2 as
 # published by the Free Software Foundation.
@@ -25,12 +25,17 @@
 # with this program; if not, write to the Free Software Foundation, Inc.,
 # 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.

-import re, bb, os, sys, time
+from __future__ import absolute_import
+import re, bb, os
 import bb.fetch, bb.build, bb.utils
-from bb import data, fetch, methodpool
+from bb import data

-from ConfHandler import include, localpath, obtain, init
-from bb.parse import ParseError
+from . import ConfHandler
+from .. import resolve_file, ast
+from .ConfHandler import include, init
+
+# For compatibility
+bb.deprecate_import(__name__, "bb.parse", ["vars_from_file"])

 __func_start_regexp__    = re.compile( r"(((?P<py>python)|(?P<fr>fakeroot))\s*)*(?P<func>[\w\.\-\+\{\}\$]+)?\s*\(\s*\)\s*{$" )
 __inherit_regexp__       = re.compile( r"inherit\s+(.+)" )
@@ -39,7 +44,7 @@ __addtask_regexp__       = re.compile("addtask\s+(?P<func>\w+)\s*((before\s*(?P<
 __addhandler_regexp__    = re.compile( r"addhandler\s+(.+)" )
 __def_regexp__           = re.compile( r"def\s+(\w+).*:" )
 __python_func_regexp__   = re.compile( r"(\s+.*)|(^$)" )
-__word__ = re.compile(r"\S+")
+

 __infunc__ = ""
 __inpython__ = False
@@ -47,6 +52,8 @@ __body__   = []
 __classname__ = ""
 classes = [ None, ]

+cached_statements = {}
+
 # We need to indicate EOF to the feeder. This code is so messy that
 # factoring it out to a close_parse_file method is out of question.
 # We will use the IN_PYTHON_EOF as an indicator to just close the method
@@ -54,18 +61,17 @@ classes = [ None, ]
 # The two parts using it are tightly integrated anyway
 IN_PYTHON_EOF = -9999999999999

-__parsed_methods__ = methodpool.get_parsed_dict()
+

 def supports(fn, d):
-    localfn = localpath(fn, d)
-    return localfn[-3:] == ".bb" or localfn[-8:] == ".bbclass" or localfn[-4:] == ".inc"
+    return fn[-3:] == ".bb" or fn[-8:] == ".bbclass" or fn[-4:] == ".inc"

 def inherit(files, d):
    __inherit_cache = data.getVar('__inherit_cache', d) or []
    fn = ""
    lineno = 0
-    files = data.expand(files, d)
    for file in files:
+        file = data.expand(file, d)
        if file[0] != "/" and file[-8:] != ".bbclass":
            file = os.path.join('classes', '%s.bbclass' % file)

@@ -76,146 +82,95 @@ def inherit(files, d):
            include(fn, file, d, "inherit")
            __inherit_cache = data.getVar('__inherit_cache', d) or []

-def handle(fn, d, include = 0):
+def get_statements(filename, absolute_filename, base_name):
+    global cached_statements
+
+    try:
+        return cached_statements[absolute_filename]
+    except KeyError:
+        file = open(absolute_filename, 'r')
+        statements = ast.StatementGroup()
+
+        lineno = 0
+        while True:
+            lineno = lineno + 1
+            s = file.readline()
+            if not s: break
+            s = s.rstrip()
+            feeder(lineno, s, filename, base_name, statements)
+        if __inpython__:
+            # add a blank line to close out any python definition
+            feeder(IN_PYTHON_EOF, "", filename, base_name, statements)
+
+        if filename.endswith(".bbclass") or filename.endswith(".inc"):
+            cached_statements[absolute_filename] = statements
+        return statements
+
+def handle(fn, d, include):
    global __func_start_regexp__, __inherit_regexp__, __export_func_regexp__, __addtask_regexp__, __addhandler_regexp__, __infunc__, __body__, __residue__
    __body__ = []
    __infunc__ = ""
    __classname__ = ""
    __residue__ = []

+
    if include == 0:
        bb.msg.debug(2, bb.msg.domain.Parsing, "BB " + fn + ": handle(data)")
    else:
        bb.msg.debug(2, bb.msg.domain.Parsing, "BB " + fn + ": handle(data, include)")

    (root, ext) = os.path.splitext(os.path.basename(fn))
-    base_name = "%s%s" % (root,ext)
+    base_name = "%s%s" % (root, ext)
    init(d)

    if ext == ".bbclass":
        __classname__ = root
        classes.append(__classname__)
+        __inherit_cache = data.getVar('__inherit_cache', d) or []
+        if not fn in __inherit_cache:
+            __inherit_cache.append(fn)
+            data.setVar('__inherit_cache', __inherit_cache, d)

    if include != 0:
        oldfile = data.getVar('FILE', d)
    else:
        oldfile = None

-    fn = obtain(fn, d)
-    bbpath = (data.getVar('BBPATH', d, 1) or '').split(':')
-    if not os.path.isabs(fn):
-        f = None
-        for p in bbpath:
-            j = os.path.join(p, fn)
-            if os.access(j, os.R_OK):
-                abs_fn = j
-                f = open(j, 'r')
-                break
-        if f is None:
-            raise IOError("file not found")
-    else:
-        f = open(fn,'r')
-        abs_fn = fn
-
-    if ext != ".bbclass":
-        bbpath.insert(0, os.path.dirname(abs_fn))
-        data.setVar('BBPATH', ":".join(bbpath), d)
+    abs_fn = resolve_file(fn, d)

    if include:
        bb.parse.mark_dependency(d, abs_fn)

+    # actual loading
+    statements = get_statements(fn, abs_fn, base_name)
+
+    # DONE WITH PARSING... time to evaluate
    if ext != ".bbclass":
        data.setVar('FILE', fn, d)
-        i = (data.getVar("INHERIT", d, 1) or "").split()
-        if not "base" in i and __classname__ != "base":
-            i[0:0] = ["base"]
-        inherit(i, d)

-    lineno = 0
-    while 1:
-        lineno = lineno + 1
-        s = f.readline()
-        if not s: break
-        s = s.rstrip()
-        feeder(lineno, s, fn, base_name, d)
-    if __inpython__:
-        # add a blank line to close out any python definition
-        feeder(IN_PYTHON_EOF, "", fn, base_name, d)
+    statements.eval(d)
+
    if ext == ".bbclass":
        classes.remove(__classname__)
    else:
        if include == 0:
-            data.expandKeys(d)
-            data.update_data(d)
-            anonqueue = data.getVar("__anonqueue", d, 1) or []
-            body = [x['content'] for x in anonqueue]
-            flag = { 'python' : 1, 'func' : 1 }
-            data.setVar("__anonfunc", "\n".join(body), d)
-            data.setVarFlags("__anonfunc", flag, d)
-            from bb import build
-            try:
-                t = data.getVar('T', d)
-                data.setVar('T', '${TMPDIR}/', d)
-                build.exec_func("__anonfunc", d)
-                data.delVar('T', d)
-                if t:
-                    data.setVar('T', t, d)
-            except Exception, e:
-                bb.msg.debug(1, bb.msg.domain.Parsing, "executing anonymous function: %s" % e)
-                raise
-            data.delVar("__anonqueue", d)
-            data.delVar("__anonfunc", d)
-            set_additional_vars(fn, d, include)
-            data.update_data(d)
+            return ast.multi_finalize(fn, d)

-            all_handlers = {} 
-            for var in data.getVar('__BBHANDLERS', d) or []:
-                # try to add the handler
-                # if we added it remember the choiche
-                handler = data.getVar(var,d)
-                if bb.event.register(var,handler) == bb.event.Registered:
-                    all_handlers[var] = handler
-
-            for var in data.getVar('__BBTASKS', d) or []:
-                deps = data.getVarFlag(var, 'deps', d) or []
-                postdeps = data.getVarFlag(var, 'postdeps', d) or []
-                bb.build.add_task(var, deps, d)
-                for p in postdeps:
-                    pdeps = data.getVarFlag(p, 'deps', d) or []
-                    pdeps.append(var)
-                    data.setVarFlag(p, 'deps', pdeps, d)
-                    bb.build.add_task(p, pdeps, d)
-
-            # now add the handlers
-            if not len(all_handlers) == 0:
-                data.setVar('__all_handlers__', all_handlers, d)
-
-        bbpath.pop(0)
    if oldfile:
        bb.data.setVar("FILE", oldfile, d)

    # we have parsed the bb class now
    if ext == ".bbclass" or ext == ".inc":
-        __parsed_methods__[base_name] = 1
+        bb.methodpool.get_parsed_dict()[base_name] = 1

    return d

-def feeder(lineno, s, fn, root, d):
-    global __func_start_regexp__, __inherit_regexp__, __export_func_regexp__, __addtask_regexp__, __addhandler_regexp__, __def_regexp__, __python_func_regexp__, __inpython__,__infunc__, __body__, classes, bb, __residue__
+def feeder(lineno, s, fn, root, statements):
+    global __func_start_regexp__, __inherit_regexp__, __export_func_regexp__, __addtask_regexp__, __addhandler_regexp__, __def_regexp__, __python_func_regexp__, __inpython__, __infunc__, __body__, classes, bb, __residue__
    if __infunc__:
        if s == '}':
            __body__.append('')
-            data.setVar(__infunc__, '\n'.join(__body__), d)
-            data.setVarFlag(__infunc__, "func", 1, d)
-            if __infunc__ == "__anonymous":
-                anonqueue = bb.data.getVar("__anonqueue", d) or []
-                anonitem = {}
-                anonitem["content"] = bb.data.getVar("__anonymous", d)
-                anonitem["flags"] = bb.data.getVarFlags("__anonymous", d)
-                anonqueue.append(anonitem)
-                bb.data.setVar("__anonqueue", anonqueue, d)
-                bb.data.delVarFlags("__anonymous", d)
-                bb.data.delVar("__anonymous", d)
+            ast.handleMethod(statements, __infunc__, lineno, fn, __body__)
            __infunc__ = ""
            __body__ = []
        else:
@@ -228,19 +183,7 @@ def feeder(lineno, s, fn, root, d):
            __body__.append(s)
            return
        else:
-            # Note we will add root to parsedmethods after having parse
-            # 'this' file. This means we will not parse methods from
-            # bb classes twice
-            if not root  in __parsed_methods__:
-                text = '\n'.join(__body__)
-                methodpool.insert_method( root, text, fn )
-                funcs = data.getVar('__functions__', d) or {}
-                if not funcs.has_key( root ):
-                    funcs[root] = text 
-                else:
-                    funcs[root] = "%s\n%s" % (funcs[root], text)
-
-                data.setVar('__functions__', funcs, d)
+            ast.handlePythonMethod(statements, __inpython__, root, __body__, fn)
            __body__ = []
            __inpython__ = False

@@ -261,157 +204,39 @@ def feeder(lineno, s, fn, root, d):
    m = __func_start_regexp__.match(s)
    if m:
        __infunc__ = m.group("func") or "__anonymous"
-        key = __infunc__
-        if data.getVar(key, d):
-#           clean up old version of this piece of metadata, as its
-#           flags could cause problems
-            data.setVarFlag(key, 'python', None, d)
-            data.setVarFlag(key, 'fakeroot', None, d)
-        if m.group("py") is not None:
-            data.setVarFlag(key, "python", "1", d)
-        else:
-            data.delVarFlag(key, "python", d)
-        if m.group("fr") is not None:
-            data.setVarFlag(key, "fakeroot", "1", d)
-        else:
-            data.delVarFlag(key, "fakeroot", d)
+        ast.handleMethodFlags(statements, __infunc__, m)
        return

    m = __def_regexp__.match(s)
    if m:
        __body__.append(s)
-        __inpython__ = True
+        __inpython__ = m.group(1)
+
        return

    m = __export_func_regexp__.match(s)
    if m:
-        fns = m.group(1)
-        n = __word__.findall(fns)
-        for f in n:
-            allvars = []
-            allvars.append(f)
-            allvars.append(classes[-1] + "_" + f)
-
-            vars = [[ allvars[0], allvars[1] ]]
-            if len(classes) > 1 and classes[-2] is not None:
-                allvars.append(classes[-2] + "_" + f)
-                vars = []
-                vars.append([allvars[2], allvars[1]])
-                vars.append([allvars[0], allvars[2]])
-
-            for (var, calledvar) in vars:
-                if data.getVar(var, d) and not data.getVarFlag(var, 'export_func', d):
-                    continue
-
-                if data.getVar(var, d):
-                    data.setVarFlag(var, 'python', None, d)
-                    data.setVarFlag(var, 'func', None, d)
-
-                for flag in [ "func", "python" ]:
-                    if data.getVarFlag(calledvar, flag, d):
-                        data.setVarFlag(var, flag, data.getVarFlag(calledvar, flag, d), d)
-                for flag in [ "dirs" ]:
-                    if data.getVarFlag(var, flag, d):
-                        data.setVarFlag(calledvar, flag, data.getVarFlag(var, flag, d), d)
-
-                if data.getVarFlag(calledvar, "python", d):
-                    data.setVar(var, "\tbb.build.exec_func('" + calledvar + "', d)\n", d)
-                else:
-                    data.setVar(var, "\t" + calledvar + "\n", d)
-                data.setVarFlag(var, 'export_func', '1', d)
-
+        ast.handleExportFuncs(statements, m, classes)
        return

    m = __addtask_regexp__.match(s)
    if m:
-        func = m.group("func")
-        before = m.group("before")
-        after = m.group("after")
-        if func is None:
-            return
-        var = "do_" + func
-
-        data.setVarFlag(var, "task", 1, d)
-
-        bbtasks = data.getVar('__BBTASKS', d) or []
-        bbtasks.append(var)
-        data.setVar('__BBTASKS', bbtasks, d)
-
-        if after is not None:
-#           set up deps for function
-            data.setVarFlag(var, "deps", after.split(), d)
-        if before is not None:
-#           set up things that depend on this func
-            data.setVarFlag(var, "postdeps", before.split(), d)
+        ast.handleAddTask(statements, m)
        return

    m = __addhandler_regexp__.match(s)
    if m:
-        fns = m.group(1)
-        hs = __word__.findall(fns)
-        bbhands = data.getVar('__BBHANDLERS', d) or []
-        for h in hs:
-            bbhands.append(h)
-            data.setVarFlag(h, "handler", 1, d)
-        data.setVar('__BBHANDLERS', bbhands, d)
+        ast.handleBBHandlers(statements, m)
        return

    m = __inherit_regexp__.match(s)
    if m:
-
-        files = m.group(1)
-        n = __word__.findall(files)
-        inherit(n, d)
+        ast.handleInherit(statements, m)
        return

-    from bb.parse import ConfHandler
-    return ConfHandler.feeder(lineno, s, fn, d)
-
-__pkgsplit_cache__={}
-def vars_from_file(mypkg, d):
-    if not mypkg:
-        return (None, None, None)
-    if mypkg in __pkgsplit_cache__:
-        return __pkgsplit_cache__[mypkg]
-
-    myfile = os.path.splitext(os.path.basename(mypkg))
-    parts = myfile[0].split('_')
-    __pkgsplit_cache__[mypkg] = parts
-    if len(parts) > 3:
-        raise ParseError("Unable to generate default variables from the filename: %s (too many underscores)" % mypkg)
-    exp = 3 - len(parts)
-    tmplist = []
-    while exp != 0:
-        exp -= 1
-        tmplist.append(None)
-    parts.extend(tmplist)
-    return parts
-
-def set_additional_vars(file, d, include):
-    """Deduce rest of variables, e.g. ${A} out of ${SRC_URI}"""
-
-    bb.msg.debug(2, bb.msg.domain.Parsing, "BB %s: set_additional_vars" % file)
-
-    src_uri = data.getVar('SRC_URI', d, 1)
-    if not src_uri:
-        return
-
-    a = (data.getVar('A', d, 1) or '').split()
-
-    from bb import fetch
-    try:
-        fetch.init(src_uri.split(), d)
-    except fetch.NoMethodError:
-        pass
-    except bb.MalformedUrl,e:
-        raise ParseError("Unable to generate local paths for SRC_URI due to malformed uri: %s" % e)
-
-    a += fetch.localpaths(d)
-    del fetch
-    data.setVar('A', " ".join(a), d)
-
+    return ConfHandler.feeder(lineno, s, fn, statements)

 # Add us to the handlers list
-from bb.parse import handlers
+from .. import handlers
 handlers.append({'supports': supports, 'handle': handle, 'init': init})
 del handlers
--- a/bitbake/lib/bb/parse/parse_py/ConfHandler.py
+++ b/bitbake/lib/bb/parse/parse_py/ConfHandler.py
@@ -10,7 +10,7 @@

 # Copyright (C) 2003, 2004  Chris Larson
 # Copyright (C) 2003, 2004  Phil Blundell
-# 
+#
 # This program is free software; you can redistribute it and/or modify
 # it under the terms of the GNU General Public License version 2 as
 # published by the Free Software Foundation.
@@ -24,67 +24,24 @@
 # with this program; if not, write to the Free Software Foundation, Inc.,
 # 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.

-import re, bb.data, os, sys
-from bb.parse import ParseError
+import re, bb.data, os
+import bb.utils
+from bb.parse import ParseError, resolve_file, ast

 #__config_regexp__  = re.compile( r"(?P<exp>export\s*)?(?P<var>[a-zA-Z0-9\-_+.${}]+)\s*(?P<colon>:)?(?P<ques>\?)?=\s*(?P<apo>['\"]?)(?P<value>.*)(?P=apo)$")
-__config_regexp__  = re.compile( r"(?P<exp>export\s*)?(?P<var>[a-zA-Z0-9\-_+.${}/]+)(\[(?P<flag>[a-zA-Z0-9\-_+.]+)\])?\s*((?P<colon>:=)|(?P<ques>\?=)|(?P<append>\+=)|(?P<prepend>=\+)|(?P<predot>=\.)|(?P<postdot>\.=)|=)\s*(?P<apo>['\"]?)(?P<value>.*)(?P=apo)$")
+__config_regexp__  = re.compile( r"(?P<exp>export\s*)?(?P<var>[a-zA-Z0-9\-_+.${}/]+)(\[(?P<flag>[a-zA-Z0-9\-_+.]+)\])?\s*((?P<colon>:=)|(?P<lazyques>\?\?=)|(?P<ques>\?=)|(?P<append>\+=)|(?P<prepend>=\+)|(?P<predot>=\.)|(?P<postdot>\.=)|=)\s*(?P<apo>['\"]?)(?P<value>.*)(?P=apo)$")
 __include_regexp__ = re.compile( r"include\s+(.+)" )
 __require_regexp__ = re.compile( r"require\s+(.+)" )
+__export_regexp__ = re.compile( r"export\s+(.+)" )

 def init(data):
-    if not bb.data.getVar('TOPDIR', data):
+    topdir = bb.data.getVar('TOPDIR', data)
+    if not topdir:
        bb.data.setVar('TOPDIR', os.getcwd(), data)
-    if not bb.data.getVar('BBPATH', data):
-        bb.data.setVar('BBPATH', os.path.join(sys.prefix, 'share', 'bitbake'), data)
+

 def supports(fn, d):
-    return localpath(fn, d)[-5:] == ".conf"
-
-def localpath(fn, d):
-    if os.path.exists(fn):
-        return fn
-
-    localfn = None
-    try:
-        localfn = bb.fetch.localpath(fn, d)
-    except bb.MalformedUrl:
-        pass
-
-    if not localfn:
-        localfn = fn
-    return localfn
-
-def obtain(fn, data):
-    import sys, bb
-    fn = bb.data.expand(fn, data)
-    localfn = bb.data.expand(localpath(fn, data), data)
-
-    if localfn != fn:
-        dldir = bb.data.getVar('DL_DIR', data, 1)
-        if not dldir:
-            bb.msg.debug(1, bb.msg.domain.Parsing, "obtain: DL_DIR not defined")
-            return localfn
-        bb.mkdirhier(dldir)
-        try:
-            bb.fetch.init([fn])
-        except bb.fetch.NoMethodError:
-            (type, value, traceback) = sys.exc_info()
-            bb.msg.debug(1, bb.msg.domain.Parsing, "obtain: no method: %s" % value)
-            return localfn
-
-        try:
-            bb.fetch.go(data)
-        except bb.fetch.MissingParameterError:
-            (type, value, traceback) = sys.exc_info()
-            bb.msg.debug(1, bb.msg.domain.Parsing, "obtain: missing parameters: %s" % value)
-            return localfn
-        except bb.fetch.FetchError:
-            (type, value, traceback) = sys.exc_info()
-            bb.msg.debug(1, bb.msg.domain.Parsing, "obtain: failed: %s" % value)
-            return localfn
-    return localfn
-
+    return fn[-5:] == ".conf"

 def include(oldfn, fn, data, error_out):
    """
@@ -98,6 +55,13 @@ def include(oldfn, fn, data, error_out):
    fn = bb.data.expand(fn, data)
    oldfn = bb.data.expand(oldfn, data)

+    if not os.path.isabs(fn):
+        dname = os.path.dirname(oldfn)
+        bbpath = "%s:%s" % (dname, bb.data.getVar("BBPATH", data, 1))
+        abs_fn = bb.utils.which(bbpath, fn)
+        if abs_fn:
+            fn = abs_fn
+
    from bb.parse import handle
    try:
        ret = handle(fn, data, True)
@@ -106,43 +70,23 @@ def include(oldfn, fn, data, error_out):
            raise ParseError("Could not %(error_out)s file %(fn)s" % vars() )
        bb.msg.debug(2, bb.msg.domain.Parsing, "CONF file '%s' not found" % fn)

-def handle(fn, data, include = 0):
-    if include:
-        inc_string = "including"
-    else:
-        inc_string = "reading"
+def handle(fn, data, include):
    init(data)

    if include == 0:
-        bb.data.inheritFromOS(data)
        oldfile = None
    else:
        oldfile = bb.data.getVar('FILE', data)

-    fn = obtain(fn, data)
-    if not os.path.isabs(fn):
-        f = None
-        bbpath = bb.data.getVar("BBPATH", data, 1) or []
-        for p in bbpath.split(":"):
-            currname = os.path.join(p, fn)
-            if os.access(currname, os.R_OK):
-                f = open(currname, 'r')
-                abs_fn = currname
-                bb.msg.debug(2, bb.msg.domain.Parsing, "CONF %s %s" % (inc_string, currname))
-                break
-        if f is None:
-            raise IOError("file '%s' not found" % fn)
-    else:
-        f = open(fn,'r')
-        bb.msg.debug(1, bb.msg.domain.Parsing, "CONF %s %s" % (inc_string,fn))
-        abs_fn = fn
+    abs_fn = resolve_file(fn, data)
+    f = open(abs_fn, 'r')

    if include:
        bb.parse.mark_dependency(data, abs_fn)

+    statements = ast.StatementGroup()
    lineno = 0
-    bb.data.setVar('FILE', fn, data)
-    while 1:
+    while True:
        lineno = lineno + 1
        s = f.readline()
        if not s: break
@@ -154,59 +98,36 @@ def handle(fn, data, include = 0):
            s2 = f.readline()[:-1].strip()
            lineno = lineno + 1
            s = s[:-1] + s2
-        feeder(lineno, s, fn, data)
+        feeder(lineno, s, fn, statements)

+    # DONE WITH PARSING... time to evaluate
+    bb.data.setVar('FILE', fn, data)
+    statements.eval(data)
    if oldfile:
        bb.data.setVar('FILE', oldfile, data)
+
    return data

-def feeder(lineno, s, fn, data):
-    def getFunc(groupd, key, data):
-        if 'flag' in groupd and groupd['flag'] != None:
-            return bb.data.getVarFlag(key, groupd['flag'], data)
-        else:
-            return bb.data.getVar(key, data)
-
+def feeder(lineno, s, fn, statements):
    m = __config_regexp__.match(s)
    if m:
        groupd = m.groupdict()
-        key = groupd["var"]
-        if "exp" in groupd and groupd["exp"] != None:
-            bb.data.setVarFlag(key, "export", 1, data)
-        if "ques" in groupd and groupd["ques"] != None:
-            val = getFunc(groupd, key, data)
-            if val == None:
-                val = groupd["value"]
-        elif "colon" in groupd and groupd["colon"] != None:
-            val = bb.data.expand(groupd["value"], data)
-        elif "append" in groupd and groupd["append"] != None:
-            val = "%s %s" % ((getFunc(groupd, key, data) or ""), groupd["value"])
-        elif "prepend" in groupd and groupd["prepend"] != None:
-            val = "%s %s" % (groupd["value"], (getFunc(groupd, key, data) or ""))
-        elif "postdot" in groupd and groupd["postdot"] != None:
-            val = "%s%s" % ((getFunc(groupd, key, data) or ""), groupd["value"])
-        elif "predot" in groupd and groupd["predot"] != None:
-            val = "%s%s" % (groupd["value"], (getFunc(groupd, key, data) or ""))
-        else:
-            val = groupd["value"]
-        if 'flag' in groupd and groupd['flag'] != None:
-            bb.msg.debug(3, bb.msg.domain.Parsing, "setVarFlag(%s, %s, %s, data)" % (key, groupd['flag'], val))
-            bb.data.setVarFlag(key, groupd['flag'], val, data)
-        else:
-            bb.data.setVar(key, val, data)
+        ast.handleData(statements, groupd)
        return

    m = __include_regexp__.match(s)
    if m:
-        s = bb.data.expand(m.group(1), data)
-        bb.msg.debug(3, bb.msg.domain.Parsing, "CONF %s:%d: including %s" % (fn, lineno, s))
-        include(fn, s, data, False)
+        ast.handleInclude(statements, m, fn, lineno, False)
        return

    m = __require_regexp__.match(s)
    if m:
-        s = bb.data.expand(m.group(1), data)
-        include(fn, s, data, "include required")
+        ast.handleInclude(statements, m, fn, lineno, True)
+        return
+
+    m = __export_regexp__.match(s)
+    if m:
+        ast.handleExport(statements, m)
        return

    raise ParseError("%s:%d: unparsed line: '%s'" % (fn, lineno, s));
--- a/bitbake/lib/bb/parse/parse_py/init.py
+++ b/bitbake/lib/bb/parse/parse_py/init.py
@@ -25,9 +25,9 @@ File parsers for the BitBake build tools.
 # 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 #
 # Based on functions from the base bb module, Copyright 2003 Holger Schurig
+
+from __future__ import absolute_import
+from . import ConfHandler
+from . import BBHandler
+
 __version__ = '1.0'
-
-__all__ = [ 'ConfHandler', 'BBHandler']
-
-import ConfHandler
-import BBHandler
--- a/bitbake/lib/bb/persist_data.py
+++ b/bitbake/lib/bb/persist_data.py
@@ -0,0 +1,133 @@
+# BitBake Persistent Data Store
+#
+# Copyright (C) 2007        Richard Purdie
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License version 2 as
+# published by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License along
+# with this program; if not, write to the Free Software Foundation, Inc.,
+# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+
+import bb, os
+import bb.utils
+
+try:
+    import sqlite3
+except ImportError:
+    try:
+        from pysqlite2 import dbapi2 as sqlite3
+    except ImportError:
+        bb.msg.fatal(bb.msg.domain.PersistData, "Importing sqlite3 and pysqlite2 failed, please install one of them. Python 2.5 or a 'python-pysqlite2' like package is likely to be what you need.")
+
+sqlversion = sqlite3.sqlite_version_info
+if sqlversion[0] < 3 or (sqlversion[0] == 3 and sqlversion[1] < 3):
+    bb.msg.fatal(bb.msg.domain.PersistData, "sqlite3 version 3.3.0 or later is required.")
+
+class PersistData:
+    """
+    BitBake Persistent Data Store
+
+    Used to store data in a central location such that other threads/tasks can
+    access them at some future date.
+
+    The "domain" is used as a key to isolate each data pool and in this
+    implementation corresponds to an SQL table. The SQL table consists of a
+    simple key and value pair.
+
+    Why sqlite? It handles all the locking issues for us.
+    """
+    def __init__(self, d, persistent_database_connection):
+        if "connection" in persistent_database_connection:
+            self.cursor = persistent_database_connection["connection"].cursor()
+            return
+        self.cachedir = bb.data.getVar("PERSISTENT_DIR", d, True) or bb.data.getVar("CACHE", d, True)
+        if self.cachedir in [None, '']:
+            bb.msg.fatal(bb.msg.domain.PersistData, "Please set the 'PERSISTENT_DIR' or 'CACHE' variable.")
+        try:
+            os.stat(self.cachedir)
+        except OSError:
+            bb.utils.mkdirhier(self.cachedir)
+
+        self.cachefile = os.path.join(self.cachedir, "bb_persist_data.sqlite3")
+        bb.msg.debug(1, bb.msg.domain.PersistData, "Using '%s' as the persistent data cache" % self.cachefile)
+
+        connection = sqlite3.connect(self.cachefile, timeout=5, isolation_level=None)
+        persistent_database_connection["connection"] = connection
+        self.cursor = persistent_database_connection["connection"].cursor()
+
+    def addDomain(self, domain):
+        """
+        Should be called before any domain is used
+        Creates it if it doesn't exist.
+        """
+        self._execute("CREATE TABLE IF NOT EXISTS %s(key TEXT, value TEXT);" % domain)
+
+    def delDomain(self, domain):
+        """
+        Removes a domain and all the data it contains
+        """
+        self._execute("DROP TABLE IF EXISTS %s;" % domain)
+
+    def getKeyValues(self, domain):
+        """
+        Return a list of key + value pairs for a domain
+        """
+        ret = {}
+        data = self._execute("SELECT key, value from %s;" % domain)
+        for row in data:
+            ret[str(row[0])] = str(row[1])
+
+        return ret
+
+    def getValue(self, domain, key):
+        """
+        Return the value of a key for a domain
+        """
+        data = self._execute("SELECT * from %s where key=?;" % domain, [key])
+        for row in data:
+            return row[1]
+
+    def setValue(self, domain, key, value):
+        """
+        Sets the value of a key for a domain
+        """
+        data = self._execute("SELECT * from %s where key=?;" % domain, [key])
+        rows = 0
+        for row in data:
+            rows = rows + 1
+        if rows:
+            self._execute("UPDATE %s SET value=? WHERE key=?;" % domain, [value, key])
+        else:
+            self._execute("INSERT into %s(key, value) values (?, ?);" % domain, [key, value])
+
+    def delValue(self, domain, key):
+        """
+        Deletes a key/value pair
+        """
+        self._execute("DELETE from %s where key=?;" % domain, [key])
+
+    #
+    # We wrap the sqlite execute calls as on contended machines or single threaded 
+    # systems we can have multiple processes trying to access the DB at once and it seems
+    # sqlite sometimes doesn't wait for the timeout. We therefore loop but put in an 
+    # emergency brake too
+    #
+    def _execute(self, *query):
+        count = 0
+        while True:
+            try:
+                ret = self.cursor.execute(*query)
+                #print "Had to retry %s times" % count
+                return ret
+            except sqlite3.OperationalError as e:
+                if 'database is locked' in str(e) and count < 500:
+                    count = count + 1
+                    continue
+                raise
--- a/bitbake/lib/bb/providers.py
+++ b/bitbake/lib/bb/providers.py
@@ -21,7 +21,7 @@
 # with this program; if not, write to the Free Software Foundation, Inc.,
 # 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.

-import os, re
+import re
 from bb import data, utils
 import bb

@@ -31,12 +31,12 @@ class NoProvider(Exception):
 class NoRProvider(Exception):
    """Exception raised when no provider of a runtime dependency can be found"""

-def findBestProvider(pn, cfgData, dataCache, pkg_pn = None, item = None):
+
+def sortPriorities(pn, dataCache, pkg_pn = None):
    """
-    If there is a PREFERRED_VERSION, find the highest-priority bbfile
-    providing that version.  If not, find the latest version provided by
-    an bbfile in the highest-priority set.
+    Reorder pkg_pn by file priority and default preference
    """
+
    if not pkg_pn:
        pkg_pn = dataCache.pkg_pn

@@ -44,19 +44,44 @@ def findBestProvider(pn, cfgData, dataCache, pkg_pn = None, item = None):
    priorities = {}
    for f in files:
        priority = dataCache.bbfile_priority[f]
+        preference = dataCache.pkg_dp[f]
        if priority not in priorities:
-            priorities[priority] = []
-        priorities[priority].append(f)
-    p_list = priorities.keys()
-    p_list.sort(lambda a, b: a - b)
+            priorities[priority] = {}
+        if preference not in priorities[priority]:
+            priorities[priority][preference] = []
+        priorities[priority][preference].append(f)
    tmp_pn = []
-    for p in p_list:
-        tmp_pn = [priorities[p]] + tmp_pn
+    for pri in sorted(priorities, lambda a, b: a - b):
+        tmp_pref = []
+        for pref in sorted(priorities[pri], lambda a, b: b - a):
+            tmp_pref.extend(priorities[pri][pref])
+        tmp_pn = [tmp_pref] + tmp_pn
+
+    return tmp_pn
+
+def preferredVersionMatch(pe, pv, pr, preferred_e, preferred_v, preferred_r):
+    """
+    Check if the version pe,pv,pr is the preferred one.
+    If there is preferred version defined and ends with '%', then pv has to start with that version after removing the '%'
+    """
+    if (pr == preferred_r or preferred_r == None):
+        if (pe == preferred_e or preferred_e == None):
+            if preferred_v == pv:
+                return True
+            if preferred_v != None and preferred_v.endswith('%') and pv.startswith(preferred_v[:len(preferred_v)-1]):
+                return True
+    return False
+
+def findPreferredProvider(pn, cfgData, dataCache, pkg_pn = None, item = None):
+    """
+    Find the first provider in pkg_pn with a PREFERRED_VERSION set.
+    """

    preferred_file = None
+    preferred_ver = None

    localdata = data.createCopy(cfgData)
-    bb.data.setVar('OVERRIDES', "%s:%s" % (pn, data.getVar('OVERRIDES', localdata)), localdata)
+    bb.data.setVar('OVERRIDES', "pn-%s:%s:%s" % (pn, pn, data.getVar('OVERRIDES', localdata)), localdata)
    bb.data.update_data(localdata)

    preferred_v = bb.data.getVar('PREFERRED_VERSION_%s' % pn, localdata, True)
@@ -76,10 +101,10 @@ def findBestProvider(pn, cfgData, dataCache, pkg_pn = None, item = None):
            preferred_e = None
            preferred_r = None

-        for file_set in tmp_pn:
+        for file_set in pkg_pn:
            for f in file_set:
-                pe,pv,pr = dataCache.pkg_pepvpr[f]
-                if preferred_v == pv and (preferred_r == pr or preferred_r == None) and (preferred_e == pe or preferred_e == None):
+                pe, pv, pr = dataCache.pkg_pepvpr[f]
+                if preferredVersionMatch(pe, pv, pr, preferred_e, preferred_v, preferred_r):
                    preferred_file = f
                    preferred_ver = (pe, pv, pr)
                    break
@@ -99,34 +124,62 @@ def findBestProvider(pn, cfgData, dataCache, pkg_pn = None, item = None):
        else:
            bb.msg.debug(1, bb.msg.domain.Provider, "selecting %s as PREFERRED_VERSION %s of package %s%s" % (preferred_file, pv_str, pn, itemstr))

-    del localdata
+    return (preferred_ver, preferred_file)

-    # get highest priority file set
-    files = tmp_pn[0]
+
+def findLatestProvider(pn, cfgData, dataCache, file_set):
+    """
+    Return the highest version of the providers in file_set.
+    Take default preferences into account.
+    """
    latest = None
    latest_p = 0
    latest_f = None
-    for file_name in files:
-        pe,pv,pr = dataCache.pkg_pepvpr[file_name]
+    for file_name in file_set:
+        pe, pv, pr = dataCache.pkg_pepvpr[file_name]
        dp = dataCache.pkg_dp[file_name]

        if (latest is None) or ((latest_p == dp) and (utils.vercmp(latest, (pe, pv, pr)) < 0)) or (dp > latest_p):
            latest = (pe, pv, pr)
            latest_f = file_name
            latest_p = dp
+
+    return (latest, latest_f)
+
+
+def findBestProvider(pn, cfgData, dataCache, pkg_pn = None, item = None):
+    """
+    If there is a PREFERRED_VERSION, find the highest-priority bbfile
+    providing that version.  If not, find the latest version provided by
+    an bbfile in the highest-priority set.
+    """
+
+    sortpkg_pn = sortPriorities(pn, dataCache, pkg_pn)
+    # Find the highest priority provider with a PREFERRED_VERSION set
+    (preferred_ver, preferred_file) = findPreferredProvider(pn, cfgData, dataCache, sortpkg_pn, item)
+    # Find the latest version of the highest priority provider
+    (latest, latest_f) = findLatestProvider(pn, cfgData, dataCache, sortpkg_pn[0])
+
    if preferred_file is None:
        preferred_file = latest_f
        preferred_ver = latest

-    return (latest,latest_f,preferred_ver, preferred_file)
+    return (latest, latest_f, preferred_ver, preferred_file)

-def filterProviders(providers, item, cfgData, dataCache):
+
+def _filterProviders(providers, item, cfgData, dataCache):
    """
-    Take a list of providers and filter/reorder according to the 
+    Take a list of providers and filter/reorder according to the
    environment variables and previous build results
    """
    eligible = []
    preferred_versions = {}
+    sortpkg_pn = {}
+
+    # The order of providers depends on the order of the files on the disk
+    # up to here. Sort pkg_pn to make dependency issues reproducible rather
+    # than effectively random.
+    providers.sort()

    # Collate providers by PN
    pkg_pn = {}
@@ -138,15 +191,24 @@ def filterProviders(providers, item, cfgData, dataCache):

    bb.msg.debug(1, bb.msg.domain.Provider, "providers for %s are: %s" % (item, pkg_pn.keys()))

-    for pn in pkg_pn.keys():
-        preferred_versions[pn] = bb.providers.findBestProvider(pn, cfgData, dataCache, pkg_pn, item)[2:4]
+    # First add PREFERRED_VERSIONS
+    for pn in pkg_pn:
+        sortpkg_pn[pn] = sortPriorities(pn, dataCache, pkg_pn)
+        preferred_versions[pn] = findPreferredProvider(pn, cfgData, dataCache, sortpkg_pn[pn], item)
+        if preferred_versions[pn][1]:
+            eligible.append(preferred_versions[pn][1])
+
+    # Now add latest versions
+    for pn in sortpkg_pn:
+        if pn in preferred_versions and preferred_versions[pn][1]:
+            continue
+        preferred_versions[pn] = findLatestProvider(pn, cfgData, dataCache, sortpkg_pn[pn][0])
        eligible.append(preferred_versions[pn][1])

    if len(eligible) == 0:
        bb.msg.error(bb.msg.domain.Provider, "no eligible providers for %s" % item)
        return 0

-
    # If pn == item, give it a slight default preference
    # This means PREFERRED_PROVIDER_foobar defaults to foobar if available
    for p in providers:
@@ -159,36 +221,75 @@ def filterProviders(providers, item, cfgData, dataCache):
        eligible.remove(fn)
        eligible = [fn] + eligible

-    # look to see if one of them is already staged, or marked as preferred.
-    # if so, bump it to the head of the queue
-    for p in providers:
-        pn = dataCache.pkg_fn[p]
-        pe, pv, pr = dataCache.pkg_pepvpr[p]
-
-        stamp = '%s.do_populate_staging' % dataCache.stamp[p]
-        if os.path.exists(stamp):
-            (newvers, fn) = preferred_versions[pn]
-            if not fn in eligible:
-                # package was made ineligible by already-failed check
-                continue
-            oldver = "%s-%s" % (pv, pr)
-            if pe > 0:
-                oldver = "%s:%s" % (pe, oldver)
-            newver = "%s-%s" % (newvers[1], newvers[2])
-            if newvers[0] > 0:
-                newver = "%s:%s" % (newvers[0], newver)
-            if (newver != oldver):
-                extra_chat = "%s (%s) already staged but upgrading to %s to satisfy %s" % (pn, oldver, newver, item)
-            else:
-                extra_chat = "Selecting already-staged %s (%s) to satisfy %s" % (pn, oldver, item)
-
-            bb.msg.note(2, bb.msg.domain.Provider, "%s" % extra_chat)
-            eligible.remove(fn)
-            eligible = [fn] + eligible
-            break
-
    return eligible

+
+def filterProviders(providers, item, cfgData, dataCache):
+    """
+    Take a list of providers and filter/reorder according to the
+    environment variables and previous build results
+    Takes a "normal" target item
+    """
+
+    eligible = _filterProviders(providers, item, cfgData, dataCache)
+
+    prefervar = bb.data.getVar('PREFERRED_PROVIDER_%s' % item, cfgData, 1)
+    if prefervar:
+        dataCache.preferred[item] = prefervar
+
+    foundUnique = False
+    if item in dataCache.preferred:
+        for p in eligible:
+            pn = dataCache.pkg_fn[p]
+            if dataCache.preferred[item] == pn:
+                bb.msg.note(2, bb.msg.domain.Provider, "selecting %s to satisfy %s due to PREFERRED_PROVIDERS" % (pn, item))
+                eligible.remove(p)
+                eligible = [p] + eligible
+                foundUnique = True
+                break
+
+    bb.msg.debug(1, bb.msg.domain.Provider, "sorted providers for %s are: %s" % (item, eligible))
+
+    return eligible, foundUnique
+
+def filterProvidersRunTime(providers, item, cfgData, dataCache):
+    """
+    Take a list of providers and filter/reorder according to the
+    environment variables and previous build results
+    Takes a "runtime" target item
+    """
+
+    eligible = _filterProviders(providers, item, cfgData, dataCache)
+
+    # Should use dataCache.preferred here?
+    preferred = []
+    preferred_vars = []
+    for p in eligible:
+        pn = dataCache.pkg_fn[p]
+        provides = dataCache.pn_provides[pn]
+        for provide in provides:
+            bb.msg.note(2, bb.msg.domain.Provider, "checking PREFERRED_PROVIDER_%s" % (provide))
+            prefervar = bb.data.getVar('PREFERRED_PROVIDER_%s' % provide, cfgData, 1)
+            if prefervar == pn:
+                var = "PREFERRED_PROVIDER_%s = %s" % (provide, prefervar)
+                bb.msg.note(2, bb.msg.domain.Provider, "selecting %s to satisfy runtime %s due to %s" % (pn, item, var))
+                preferred_vars.append(var)
+                eligible.remove(p)
+                eligible = [p] + eligible
+                preferred.append(p)
+                break
+
+    numberPreferred = len(preferred)
+
+    if numberPreferred > 1:
+        bb.msg.error(bb.msg.domain.Provider, "Conflicting PREFERRED_PROVIDER entries were found which resulted in an attempt to select multiple providers (%s) for runtime dependecy %s\nThe entries resulting in this conflict were: %s" % (preferred, item, preferred_vars))
+
+    bb.msg.debug(1, bb.msg.domain.Provider, "sorted providers for %s are: %s" % (item, eligible))
+
+    return eligible, numberPreferred
+
+regexp_cache = {}
+
 def getRuntimeProviders(dataCache, rdepend):
    """
    Return any providers of runtime dependency
@@ -196,7 +297,7 @@ def getRuntimeProviders(dataCache, rdepend):
    rproviders = []

    if rdepend in dataCache.rproviders:
-       rproviders += dataCache.rproviders[rdepend]
+        rproviders += dataCache.rproviders[rdepend]

    if rdepend in dataCache.packages:
        rproviders += dataCache.packages[rdepend]
@@ -206,7 +307,16 @@ def getRuntimeProviders(dataCache, rdepend):

    # Only search dynamic packages if we can't find anything in other variables
    for pattern in dataCache.packages_dynamic:
-        regexp = re.compile(pattern)
+        pattern = pattern.replace('+', "\+")
+        if pattern in regexp_cache:
+            regexp = regexp_cache[pattern]
+        else:
+            try:
+                regexp = re.compile(pattern)
+            except:
+                bb.msg.error(bb.msg.domain.Provider, "Error parsing re expression: %s" % pattern)
+                raise
+            regexp_cache[pattern] = regexp
        if regexp.match(rdepend):
            rproviders += dataCache.packages_dynamic[pattern]

--- a/bitbake/lib/bb/runqueue.py
+++ b/bitbake/lib/bb/runqueue.py
--- a/meta/packages/base-files/base-files/motd
+++ b/meta/packages/base-files/base-files/motd
--- a/bitbake/lib/bb/server/none.py
+++ b/bitbake/lib/bb/server/none.py
@@ -0,0 +1,181 @@
+#
+# BitBake 'dummy' Passthrough Server
+#
+# Copyright (C) 2006 - 2007  Michael 'Mickey' Lauer
+# Copyright (C) 2006 - 2008  Richard Purdie
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License version 2 as
+# published by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License along
+# with this program; if not, write to the Free Software Foundation, Inc.,
+# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+
+"""
+    This module implements an xmlrpc server for BitBake.
+
+    Use this by deriving a class from BitBakeXMLRPCServer and then adding
+    methods which you want to "export" via XMLRPC. If the methods have the
+    prefix xmlrpc_, then registering those function will happen automatically,
+    if not, you need to call register_function.
+
+    Use register_idle_function() to add a function which the xmlrpc server
+    calls from within server_forever when no requests are pending. Make sure
+    that those functions are non-blocking or else you will introduce latency
+    in the server's main loop.
+"""
+
+import time
+import bb
+from bb.ui import uievent
+import xmlrpclib
+import pickle
+
+DEBUG = False
+
+from SimpleXMLRPCServer import SimpleXMLRPCServer, SimpleXMLRPCRequestHandler
+import inspect, select
+
+class BitBakeServerCommands():
+    def __init__(self, server, cooker):
+        self.cooker = cooker
+        self.server = server
+
+    def runCommand(self, command):
+        """
+        Run a cooker command on the server
+        """
+        #print "Running Command %s" % command
+        return self.cooker.command.runCommand(command)
+
+    def terminateServer(self):
+        """
+        Trigger the server to quit
+        """
+        self.server.server_exit()
+        #print "Server (cooker) exitting"
+        return
+
+    def ping(self):
+        """
+        Dummy method which can be used to check the server is still alive
+        """
+        return True
+
+eventQueue = []
+
+class BBUIEventQueue:
+    class event:
+        def __init__(self, parent):
+            self.parent = parent
+        @staticmethod
+        def send(event):
+            bb.server.none.eventQueue.append(pickle.loads(event))
+        @staticmethod
+        def quit():
+            return
+
+    def __init__(self, BBServer):
+        self.eventQueue = bb.server.none.eventQueue
+        self.BBServer = BBServer
+        self.EventHandle = bb.event.register_UIHhandler(self)
+
+    def getEvent(self):
+        if len(self.eventQueue) == 0:
+            return None
+
+        return self.eventQueue.pop(0)
+
+    def waitEvent(self, delay):
+        event = self.getEvent()
+        if event:
+            return event
+        self.BBServer.idle_commands(delay)
+        return self.getEvent()
+
+    def queue_event(self, event):
+        self.eventQueue.append(event)
+
+    def system_quit( self ):
+        bb.event.unregister_UIHhandler(self.EventHandle)
+
+class BitBakeServer():
+    # remove this when you're done with debugging
+    # allow_reuse_address = True
+
+    def __init__(self, cooker):
+        self._idlefuns = {}
+        self.commands = BitBakeServerCommands(self, cooker)
+
+    def register_idle_function(self, function, data):
+        """Register a function to be called while the server is idle"""
+        assert hasattr(function, '__call__')
+        self._idlefuns[function] = data
+
+    def idle_commands(self, delay):
+        #print "Idle queue length %s" % len(self._idlefuns)
+        #print "Idle timeout, running idle functions"
+        #if len(self._idlefuns) == 0:
+        nextsleep = delay
+        for function, data in self._idlefuns.items():
+            try:
+                retval = function(self, data, False)
+                #print "Idle function returned %s" % (retval)
+                if retval is False:
+                    del self._idlefuns[function]
+                elif retval is True:
+                    nextsleep = None
+                elif nextsleep is None:
+                    continue
+                elif retval < nextsleep:
+                    nextsleep = retval
+            except SystemExit:
+                raise
+            except:
+                import traceback
+                traceback.print_exc()
+                self.commands.runCommand(["stateShutdown"])
+                pass
+        if nextsleep is not None:
+            #print "Sleeping for %s (%s)" % (nextsleep, delay)
+            time.sleep(nextsleep)
+
+    def server_exit(self):
+        # Tell idle functions we're exiting
+        for function, data in self._idlefuns.items():
+            try:
+                retval = function(self, data, True)
+            except:
+                pass
+
+class BitbakeServerInfo():
+    def __init__(self, server):
+        self.server = server
+        self.commands = server.commands
+
+class BitBakeServerFork():
+    def __init__(self, serverinfo, command, logfile):
+        serverinfo.forkCommand = command
+        serverinfo.logfile = logfile
+
+class BitBakeServerConnection():
+    def __init__(self, serverinfo):
+        self.server = serverinfo.server
+        self.connection = serverinfo.commands
+        self.events = bb.server.none.BBUIEventQueue(self.server)
+
+    def terminate(self):
+        try:
+            self.events.system_quit()
+        except:
+            pass
+        try:
+            self.connection.terminateServer()
+        except:
+            pass
--- a/bitbake/lib/bb/server/xmlrpc.py
+++ b/bitbake/lib/bb/server/xmlrpc.py
@@ -0,0 +1,186 @@
+#
+# BitBake XMLRPC Server
+#
+# Copyright (C) 2006 - 2007  Michael 'Mickey' Lauer
+# Copyright (C) 2006 - 2008  Richard Purdie
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License version 2 as
+# published by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License along
+# with this program; if not, write to the Free Software Foundation, Inc.,
+# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+
+"""
+    This module implements an xmlrpc server for BitBake.
+
+    Use this by deriving a class from BitBakeXMLRPCServer and then adding
+    methods which you want to "export" via XMLRPC. If the methods have the
+    prefix xmlrpc_, then registering those function will happen automatically,
+    if not, you need to call register_function.
+
+    Use register_idle_function() to add a function which the xmlrpc server
+    calls from within server_forever when no requests are pending. Make sure
+    that those functions are non-blocking or else you will introduce latency
+    in the server's main loop.
+"""
+
+import bb
+import xmlrpclib, sys
+from bb import daemonize
+from bb.ui import uievent
+
+DEBUG = False
+
+from SimpleXMLRPCServer import SimpleXMLRPCServer, SimpleXMLRPCRequestHandler
+import inspect, select
+
+if sys.hexversion < 0x020600F0:
+    print("Sorry, python 2.6 or later is required for bitbake's XMLRPC mode")
+    sys.exit(1)
+
+class BitBakeServerCommands():
+    def __init__(self, server, cooker):
+        self.cooker = cooker
+        self.server = server
+
+    def registerEventHandler(self, host, port):
+        """
+        Register a remote UI Event Handler
+        """
+        s = xmlrpclib.Server("http://%s:%d" % (host, port), allow_none=True)
+        return bb.event.register_UIHhandler(s)
+
+    def unregisterEventHandler(self, handlerNum):
+        """
+        Unregister a remote UI Event Handler
+        """
+        return bb.event.unregister_UIHhandler(handlerNum)
+
+    def runCommand(self, command):
+        """
+        Run a cooker command on the server
+        """
+        return self.cooker.command.runCommand(command)
+
+    def terminateServer(self):
+        """
+        Trigger the server to quit
+        """
+        self.server.quit = True
+        print("Server (cooker) exitting")
+        return
+
+    def ping(self):
+        """
+        Dummy method which can be used to check the server is still alive
+        """
+        return True
+
+class BitBakeServer(SimpleXMLRPCServer):
+    # remove this when you're done with debugging
+    # allow_reuse_address = True
+
+    def __init__(self, cooker, interface = ("localhost", 0)):
+        """
+        Constructor
+        """
+        SimpleXMLRPCServer.__init__(self, interface,
+                                    requestHandler=SimpleXMLRPCRequestHandler,
+                                    logRequests=False, allow_none=True)
+        self._idlefuns = {}
+        self.host, self.port = self.socket.getsockname()
+        #self.register_introspection_functions()
+        commands = BitBakeServerCommands(self, cooker)
+        self.autoregister_all_functions(commands, "")
+
+    def autoregister_all_functions(self, context, prefix):
+        """
+        Convenience method for registering all functions in the scope
+        of this class that start with a common prefix
+        """
+        methodlist = inspect.getmembers(context, inspect.ismethod)
+        for name, method in methodlist:
+            if name.startswith(prefix):
+                self.register_function(method, name[len(prefix):])
+
+    def register_idle_function(self, function, data):
+        """Register a function to be called while the server is idle"""
+        assert hasattr(function, '__call__')
+        self._idlefuns[function] = data
+
+    def serve_forever(self):
+        """
+        Serve Requests. Overloaded to honor a quit command
+        """
+        self.quit = False
+        self.timeout = 0 # Run Idle calls for our first callback
+        while not self.quit:
+            #print "Idle queue length %s" % len(self._idlefuns)
+            self.handle_request()
+            #print "Idle timeout, running idle functions"
+            nextsleep = None
+            for function, data in self._idlefuns.items():
+                try:
+                    retval = function(self, data, False)
+                    if retval is False:
+                        del self._idlefuns[function]
+                    elif retval is True:
+                        nextsleep = 0
+                    elif nextsleep is 0:
+                        continue
+                    elif nextsleep is None:
+                        nextsleep = retval
+                    elif retval < nextsleep:
+                        nextsleep = retval
+                except SystemExit:
+                    raise
+                except:
+                    import traceback
+                    traceback.print_exc()
+                    pass
+            if nextsleep is None and len(self._idlefuns) > 0:
+                nextsleep = 0
+            self.timeout = nextsleep
+        # Tell idle functions we're exiting
+        for function, data in self._idlefuns.items():
+            try:
+                retval = function(self, data, True)
+            except:
+                pass
+
+        self.server_close()
+        return
+
+class BitbakeServerInfo():
+    def __init__(self, server):
+        self.host = server.host
+        self.port = server.port
+
+class BitBakeServerFork():
+    def __init__(self, serverinfo, command, logfile):
+        daemonize.createDaemon(command, logfile)
+
+class BitBakeServerConnection():
+    def __init__(self, serverinfo):
+        self.connection = xmlrpclib.Server("http://%s:%s" % (serverinfo.host, serverinfo.port),  allow_none=True)
+        self.events = uievent.BBUIEventQueue(self.connection)
+
+    def terminate(self):
+        # Don't wait for server indefinitely
+        import socket
+        socket.setdefaulttimeout(2)
+        try:
+            self.events.system_quit()
+        except:
+            pass
+        try:
+            self.connection.terminateServer()
+        except:
+            pass
--- a/bitbake/lib/bb/shell.py
+++ b/bitbake/lib/bb/shell.py
@@ -52,12 +52,14 @@ PROBLEMS:
 # Import and setup global variables
 ##########################################################################

+from __future__ import print_function
+from functools import reduce
 try:
    set
 except NameError:
    from sets import Set as set
-import sys, os, readline, socket, httplib, urllib, commands, popen2, copy, shlex, Queue, fnmatch
-from bb import data, parse, build, fatal, cache, taskdata, runqueue, providers as Providers
+import sys, os, readline, socket, httplib, urllib, commands, popen2, shlex, Queue, fnmatch
+from bb import data, parse, build, cache, taskdata, runqueue, providers as Providers

 __version__ = "0.5.3.1"
 __credits__ = """BitBake Shell Version %s (C) 2005 Michael 'Mickey' Lauer <mickey@Vanille.de>
@@ -68,7 +70,6 @@ leave_mainloop = False
 last_exception = None
 cooker = None
 parsed = False
-initdata = None
 debug = os.environ.get( "BBSHELL_DEBUG", "" )

 ##########################################################################
@@ -99,7 +100,7 @@ class BitBakeShellCommands:

    def _checkParsed( self ):
        if not parsed:
-            print "SHELL: This command needs to parse bbfiles..."
+            print("SHELL: This command needs to parse bbfiles...")
            self.parse( None )

    def _findProvider( self, item ):
@@ -120,74 +121,73 @@ class BitBakeShellCommands:
        """Register a new name for a command"""
        new, old = params
        if not old in cmds:
-            print "ERROR: Command '%s' not known" % old
+            print("ERROR: Command '%s' not known" % old)
        else:
            cmds[new] = cmds[old]
-            print "OK"
+            print("OK")
    alias.usage = "<alias> <command>"

    def buffer( self, params ):
        """Dump specified output buffer"""
        index = params[0]
-        print self._shell.myout.buffer( int( index ) )
+        print(self._shell.myout.buffer( int( index ) ))
    buffer.usage = "<index>"

    def buffers( self, params ):
        """Show the available output buffers"""
        commands = self._shell.myout.bufferedCommands()
        if not commands:
-            print "SHELL: No buffered commands available yet. Start doing something."
+            print("SHELL: No buffered commands available yet. Start doing something.")
        else:
-            print "="*35, "Available Output Buffers", "="*27
+            print("="*35, "Available Output Buffers", "="*27)
            for index, cmd in enumerate( commands ):
-                print "| %s %s" % ( str( index ).ljust( 3 ), cmd )
-            print "="*88
+                print("| %s %s" % ( str( index ).ljust( 3 ), cmd ))
+            print("="*88)

    def build( self, params, cmd = "build" ):
        """Build a providee"""
        global last_exception
        globexpr = params[0]
        self._checkParsed()
-        names = globfilter( cooker.status.pkg_pn.keys(), globexpr )
+        names = globfilter( cooker.status.pkg_pn, globexpr )
        if len( names ) == 0: names = [ globexpr ]
-        print "SHELL: Building %s" % ' '.join( names )
-
-        oldcmd = cooker.configuration.cmd
-        cooker.configuration.cmd = cmd
+        print("SHELL: Building %s" % ' '.join( names ))

        td = taskdata.TaskData(cooker.configuration.abort)
+        localdata = data.createCopy(cooker.configuration.data)
+        data.update_data(localdata)
+        data.expandKeys(localdata)

        try:
            tasks = []
            for name in names:
-                td.add_provider(cooker.configuration.data, cooker.status, name)
+                td.add_provider(localdata, cooker.status, name)
                providers = td.get_provider(name)

                if len(providers) == 0:
                    raise Providers.NoProvider

-                tasks.append([name, "do_%s" % cooker.configuration.cmd])
+                tasks.append([name, "do_%s" % cmd])

-            td.add_unresolved(cooker.configuration.data, cooker.status)
-            
-            rq = runqueue.RunQueue(cooker, cooker.configuration.data, cooker.status, td, tasks)
+            td.add_unresolved(localdata, cooker.status)
+
+            rq = runqueue.RunQueue(cooker, localdata, cooker.status, td, tasks)
            rq.prepare_runqueue()
            rq.execute_runqueue()

        except Providers.NoProvider:
-            print "ERROR: No Provider"
+            print("ERROR: No Provider")
            last_exception = Providers.NoProvider

-        except runqueue.TaskFailure, fnids:
+        except runqueue.TaskFailure as fnids:
            for fnid in fnids:
-                print "ERROR: '%s' failed" % td.fn_index[fnid]
+                print("ERROR: '%s' failed" % td.fn_index[fnid])
            last_exception = runqueue.TaskFailure

-        except build.EventException, e:
-            print "ERROR: Couldn't build '%s'" % names
+        except build.EventException as e:
+            print("ERROR: Couldn't build '%s'" % names)
            last_exception = e

-        cooker.configuration.cmd = oldcmd

    build.usage = "<providee>"

@@ -206,6 +206,11 @@ class BitBakeShellCommands:
        self.build( params, "configure" )
    configure.usage = "<providee>"

+    def install( self, params ):
+        """Execute 'install' on a providee"""
+        self.build( params, "install" )
+    install.usage = "<providee>"
+
    def edit( self, params ):
        """Call $EDITOR on a providee"""
        name = params[0]
@@ -213,12 +218,12 @@ class BitBakeShellCommands:
        if bbfile is not None:
            os.system( "%s %s" % ( os.environ.get( "EDITOR", "vi" ), bbfile ) )
        else:
-            print "ERROR: Nothing provides '%s'" % name
+            print("ERROR: Nothing provides '%s'" % name)
    edit.usage = "<providee>"

    def environment( self, params ):
-        """Dump out the outer BitBake environment (see bbread)"""
-        data.emit_env(sys.__stdout__, cooker.configuration.data, True)
+        """Dump out the outer BitBake environment"""
+        cooker.showEnvironment()

    def exit_( self, params ):
        """Leave the BitBake Shell"""
@@ -236,35 +241,16 @@ class BitBakeShellCommands:
        global last_exception
        name = params[0]
        bf = completeFilePath( name )
-        print "SHELL: Calling '%s' on '%s'" % ( cmd, bf )
+        print("SHELL: Calling '%s' on '%s'" % ( cmd, bf ))

-        oldcmd = cooker.configuration.cmd
-        cooker.configuration.cmd = cmd
-
-        thisdata = copy.deepcopy( initdata )
-        # Caution: parse.handle modifies thisdata, hence it would
-        # lead to pollution cooker.configuration.data, which is
-        # why we use it on a safe copy we obtained from cooker right after
-        # parsing the initial *.conf files
        try:
-            bbfile_data = parse.handle( bf, thisdata )
+            cooker.buildFile(bf, cmd)
        except parse.ParseError:
-            print "ERROR: Unable to open or parse '%s'" % bf
-        else:
-            # Remove stamp for target if force mode active
-            if cooker.configuration.force:
-                bb.msg.note(2, bb.msg.domain.RunQueue, "Remove stamp %s, %s" % (cmd, bf))
-                bb.build.del_stamp('do_%s' % cmd, bbfile_data)
+            print("ERROR: Unable to open or parse '%s'" % bf)
+        except build.EventException as e:
+            print("ERROR: Couldn't build '%s'" % name)
+            last_exception = e

-            item = data.getVar('PN', bbfile_data, 1)
-            data.setVar( "_task_cache", [], bbfile_data ) # force
-            try:
-                cooker.tryBuildPackage( os.path.abspath( bf ), item, cmd, bbfile_data, True )
-            except build.EventException, e:
-                print "ERROR: Couldn't build '%s'" % name
-                last_exception = e
-
-        cooker.configuration.cmd = oldcmd
    fileBuild.usage = "<bbfile>"

    def fileClean( self, params ):
@@ -286,64 +272,62 @@ class BitBakeShellCommands:
    def fileReparse( self, params ):
        """(re)Parse a bb file"""
        bbfile = params[0]
-        print "SHELL: Parsing '%s'" % bbfile
+        print("SHELL: Parsing '%s'" % bbfile)
        parse.update_mtime( bbfile )
        cooker.bb_cache.cacheValidUpdate(bbfile)
-        fromCache = cooker.bb_cache.loadData(bbfile, cooker.configuration.data)
+        fromCache = cooker.bb_cache.loadData(bbfile, cooker.configuration.data, cooker.status)
        cooker.bb_cache.sync()
        if False: #fromCache:
-            print "SHELL: File has not been updated, not reparsing"
+            print("SHELL: File has not been updated, not reparsing")
        else:
-            print "SHELL: Parsed"
+            print("SHELL: Parsed")
    fileReparse.usage = "<bbfile>"

    def abort( self, params ):
        """Toggle abort task execution flag (see bitbake -k)"""
        cooker.configuration.abort = not cooker.configuration.abort
-        print "SHELL: Abort Flag is now '%s'" % repr( cooker.configuration.abort )
+        print("SHELL: Abort Flag is now '%s'" % repr( cooker.configuration.abort ))

    def force( self, params ):
        """Toggle force task execution flag (see bitbake -f)"""
        cooker.configuration.force = not cooker.configuration.force
-        print "SHELL: Force Flag is now '%s'" % repr( cooker.configuration.force )
+        print("SHELL: Force Flag is now '%s'" % repr( cooker.configuration.force ))

    def help( self, params ):
        """Show a comprehensive list of commands and their purpose"""
-        print "="*30, "Available Commands", "="*30
-        allcmds = cmds.keys()
-        allcmds.sort()
-        for cmd in allcmds:
-            function,numparams,usage,helptext = cmds[cmd]
-            print "| %s | %s" % (usage.ljust(30), helptext)
-        print "="*78
+        print("="*30, "Available Commands", "="*30)
+        for cmd in sorted(cmds):
+            function, numparams, usage, helptext = cmds[cmd]
+            print("| %s | %s" % (usage.ljust(30), helptext))
+        print("="*78)

    def lastError( self, params ):
        """Show the reason or log that was produced by the last BitBake event exception"""
        if last_exception is None:
-            print "SHELL: No Errors yet (Phew)..."
+            print("SHELL: No Errors yet (Phew)...")
        else:
            reason, event = last_exception.args
-            print "SHELL: Reason for the last error: '%s'" % reason
+            print("SHELL: Reason for the last error: '%s'" % reason)
            if ':' in reason:
                msg, filename = reason.split( ':' )
                filename = filename.strip()
-                print "SHELL: Dumping log file for last error:"
+                print("SHELL: Dumping log file for last error:")
                try:
-                    print open( filename ).read()
+                    print(open( filename ).read())
                except IOError:
-                    print "ERROR: Couldn't open '%s'" % filename
+                    print("ERROR: Couldn't open '%s'" % filename)

    def match( self, params ):
        """Dump all files or providers matching a glob expression"""
        what, globexpr = params
        if what == "files":
            self._checkParsed()
-            for key in globfilter( cooker.status.pkg_fn.keys(), globexpr ): print key
+            for key in globfilter( cooker.status.pkg_fn, globexpr ): print(key)
        elif what == "providers":
            self._checkParsed()
-            for key in globfilter( cooker.status.pkg_pn.keys(), globexpr ): print key
+            for key in globfilter( cooker.status.pkg_pn, globexpr ): print(key)
        else:
-            print "Usage: match %s" % self.print_.usage
+            print("Usage: match %s" % self.print_.usage)
    match.usage = "<files|providers> <glob>"

    def new( self, params ):
@@ -353,15 +337,15 @@ class BitBakeShellCommands:
        fulldirname = "%s/%s" % ( packages, dirname )

        if not os.path.exists( fulldirname ):
-            print "SHELL: Creating '%s'" % fulldirname
+            print("SHELL: Creating '%s'" % fulldirname)
            os.mkdir( fulldirname )
        if os.path.exists( fulldirname ) and os.path.isdir( fulldirname ):
            if os.path.exists( "%s/%s" % ( fulldirname, filename ) ):
-                print "SHELL: ERROR: %s/%s already exists" % ( fulldirname, filename )
+                print("SHELL: ERROR: %s/%s already exists" % ( fulldirname, filename ))
                return False
-            print "SHELL: Creating '%s/%s'" % ( fulldirname, filename )
+            print("SHELL: Creating '%s/%s'" % ( fulldirname, filename ))
            newpackage = open( "%s/%s" % ( fulldirname, filename ), "w" )
-            print >>newpackage,"""DESCRIPTION = ""
+            print("""DESCRIPTION = ""
 SECTION = ""
 AUTHOR = ""
 HOMEPAGE = ""
@@ -388,11 +372,16 @@ SRC_URI = ""
 #do_install() {
 #
 #}
-"""
+""", file=newpackage)
            newpackage.close()
            os.system( "%s %s/%s" % ( os.environ.get( "EDITOR" ), fulldirname, filename ) )
    new.usage = "<directory> <filename>"

+    def package( self, params ):
+        """Execute 'package' on a providee"""
+        self.build( params, "package" )
+    package.usage = "<providee>"
+
    def pasteBin( self, params ):
        """Send a command + output buffer to the pastebin at http://rafb.net/paste"""
        index = params[0]
@@ -403,14 +392,14 @@ SRC_URI = ""
    def pasteLog( self, params ):
        """Send the last event exception error log (if there is one) to http://rafb.net/paste"""
        if last_exception is None:
-            print "SHELL: No Errors yet (Phew)..."
+            print("SHELL: No Errors yet (Phew)...")
        else:
            reason, event = last_exception.args
-            print "SHELL: Reason for the last error: '%s'" % reason
+            print("SHELL: Reason for the last error: '%s'" % reason)
            if ':' in reason:
                msg, filename = reason.split( ':' )
                filename = filename.strip()
-                print "SHELL: Pasting log file to pastebin..."
+                print("SHELL: Pasting log file to pastebin...")

                file = open( filename ).read()
                sendToPastebin( "contents of " + filename, file )
@@ -432,23 +421,23 @@ SRC_URI = ""
        cooker.buildDepgraph()
        global parsed
        parsed = True
-        print
+        print()

    def reparse( self, params ):
        """(re)Parse a providee's bb file"""
        bbfile = self._findProvider( params[0] )
        if bbfile is not None:
-            print "SHELL: Found bbfile '%s' for '%s'" % ( bbfile, params[0] )
+            print("SHELL: Found bbfile '%s' for '%s'" % ( bbfile, params[0] ))
            self.fileReparse( [ bbfile ] )
        else:
-            print "ERROR: Nothing provides '%s'" % params[0]
+            print("ERROR: Nothing provides '%s'" % params[0])
    reparse.usage = "<providee>"

    def getvar( self, params ):
        """Dump the contents of an outer BitBake environment variable"""
        var = params[0]
        value = data.getVar( var, cooker.configuration.data, 1 )
-        print value
+        print(value)
    getvar.usage = "<variable>"

    def peek( self, params ):
@@ -458,9 +447,9 @@ SRC_URI = ""
        if bbfile is not None:
            the_data = cooker.bb_cache.loadDataFull(bbfile, cooker.configuration.data)
            value = the_data.getVar( var, 1 )
-            print value
+            print(value)
        else:
-            print "ERROR: Nothing provides '%s'" % name
+            print("ERROR: Nothing provides '%s'" % name)
    peek.usage = "<providee> <variable>"

    def poke( self, params ):
@@ -468,7 +457,7 @@ SRC_URI = ""
        name, var, value = params
        bbfile = self._findProvider( name )
        if bbfile is not None:
-            print "ERROR: Sorry, this functionality is currently broken"
+            print("ERROR: Sorry, this functionality is currently broken")
            #d = cooker.pkgdata[bbfile]
            #data.setVar( var, value, d )

@@ -476,7 +465,7 @@ SRC_URI = ""
            #cooker.pkgdata.setDirty(bbfile, d)
            #print "OK"
        else:
-            print "ERROR: Nothing provides '%s'" % name
+            print("ERROR: Nothing provides '%s'" % name)
    poke.usage = "<providee> <variable> <value>"

    def print_( self, params ):
@@ -484,12 +473,12 @@ SRC_URI = ""
        what = params[0]
        if what == "files":
            self._checkParsed()
-            for key in cooker.status.pkg_fn.keys(): print key
+            for key in cooker.status.pkg_fn: print(key)
        elif what == "providers":
            self._checkParsed()
-            for key in cooker.status.providers.keys(): print key
+            for key in cooker.status.providers: print(key)
        else:
-            print "Usage: print %s" % self.print_.usage
+            print("Usage: print %s" % self.print_.usage)
    print_.usage = "<files|providers>"

    def python( self, params ):
@@ -502,14 +491,14 @@ SRC_URI = ""

    def showdata( self, params ):
        """Execute 'showdata' on a providee"""
-        self.build( params, "showdata" )
+        cooker.showEnvironment(None, params)
    showdata.usage = "<providee>"

    def setVar( self, params ):
        """Set an outer BitBake environment variable"""
        var, value = params
        data.setVar( var, value, cooker.configuration.data )
-        print "OK"
+        print("OK")
    setVar.usage = "<variable> <value>"

    def rebuild( self, params ):
@@ -521,27 +510,27 @@ SRC_URI = ""
    def shell( self, params ):
        """Execute a shell command and dump the output"""
        if params != "":
-            print commands.getoutput( " ".join( params ) )
+            print(commands.getoutput( " ".join( params ) ))
    shell.usage = "<...>"

    def stage( self, params ):
        """Execute 'stage' on a providee"""
-        self.build( params, "stage" )
+        self.build( params, "populate_staging" )
    stage.usage = "<providee>"

    def status( self, params ):
        """<just for testing>"""
-        print "-" * 78
-        print "building list = '%s'" % cooker.building_list
-        print "build path = '%s'" % cooker.build_path
-        print "consider_msgs_cache = '%s'" % cooker.consider_msgs_cache
-        print "build stats = '%s'" % cooker.stats
-        if last_exception is not None: print "last_exception = '%s'" % repr( last_exception.args )
-        print "memory output contents = '%s'" % self._shell.myout._buffer
+        print("-" * 78)
+        print("building list = '%s'" % cooker.building_list)
+        print("build path = '%s'" % cooker.build_path)
+        print("consider_msgs_cache = '%s'" % cooker.consider_msgs_cache)
+        print("build stats = '%s'" % cooker.stats)
+        if last_exception is not None: print("last_exception = '%s'" % repr( last_exception.args ))
+        print("memory output contents = '%s'" % self._shell.myout._buffer)

    def test( self, params ):
        """<just for testing>"""
-        print "testCommand called with '%s'" % params
+        print("testCommand called with '%s'" % params)

    def unpack( self, params ):
        """Execute 'unpack' on a providee"""
@@ -566,12 +555,12 @@ SRC_URI = ""
        try:
            providers = cooker.status.providers[item]
        except KeyError:
-            print "SHELL: ERROR: Nothing provides", preferred
+            print("SHELL: ERROR: Nothing provides", preferred)
        else:
            for provider in providers:
                if provider == pf: provider = " (***) %s" % provider
                else:              provider = "       %s" % provider
-                print provider
+                print(provider)
    which.usage = "<providee>"

 ##########################################################################
@@ -580,8 +569,9 @@ SRC_URI = ""

 def completeFilePath( bbfile ):
    """Get the complete bbfile path"""
+    if not cooker.status: return bbfile
    if not cooker.status.pkg_fn: return bbfile
-    for key in cooker.status.pkg_fn.keys():
+    for key in cooker.status.pkg_fn:
        if key.endswith( bbfile ):
            return key
    return bbfile
@@ -595,7 +585,7 @@ def sendToPastebin( desc, content ):
    mydata["nick"] = "%s@%s" % ( os.environ.get( "USER", "unknown" ), socket.gethostname() or "unknown" )
    mydata["text"] = content
    params = urllib.urlencode( mydata )
-    headers = {"Content-type": "application/x-www-form-urlencoded","Accept": "text/plain"}
+    headers = {"Content-type": "application/x-www-form-urlencoded", "Accept": "text/plain"}

    host = "rafb.net"
    conn = httplib.HTTPConnection( "%s:80" % host )
@@ -606,9 +596,9 @@ def sendToPastebin( desc, content ):

    if response.status == 302:
        location = response.getheader( "location" ) or "unknown"
-        print "SHELL: Pasted to http://%s%s" % ( host, location )
+        print("SHELL: Pasted to http://%s%s" % ( host, location ))
    else:
-        print "ERROR: %s %s" % ( response.status, response.reason )
+        print("ERROR: %s %s" % ( response.status, response.reason ))

 def completer( text, state ):
    """Return a possible readline completion"""
@@ -625,7 +615,7 @@ def completer( text, state ):
                    allmatches = cooker.configuration.data.keys()
                elif u == "<bbfile>":
                    if cooker.status.pkg_fn is None: allmatches = [ "(No Matches Available. Parsed yet?)" ]
-                    else: allmatches = [ x.split("/")[-1] for x in cooker.status.pkg_fn.keys() ]
+                    else: allmatches = [ x.split("/")[-1] for x in cooker.status.pkg_fn ]
                elif u == "<providee>":
                    if cooker.status.pkg_fn is None: allmatches = [ "(No Matches Available. Parsed yet?)" ]
                    else: allmatches = cooker.status.providers.iterkeys()
@@ -655,7 +645,7 @@ def columnize( alist, width = 80 ):
    return reduce(lambda line, word, width=width: '%s%s%s' %
                  (line,
                   ' \n'[(len(line[line.rfind('\n')+1:])
-                         + len(word.split('\n',1)[0]
+                         + len(word.split('\n', 1)[0]
                              ) >= width)],
                   word),
                  alist
@@ -730,11 +720,7 @@ class BitBakeShell:
        except IOError:
            pass  # It doesn't exist yet.

-        print __credits__
-
-        # save initial cooker configuration (will be reused in file*** commands)
-        global initdata
-        initdata = copy.deepcopy( cooker.configuration.data )
+        print(__credits__)

    def cleanup( self ):
        """Write readline history and clean up resources"""
@@ -742,7 +728,7 @@ class BitBakeShell:
        try:
            readline.write_history_file( self.historyfilename )
        except:
-            print "SHELL: Unable to save command history"
+            print("SHELL: Unable to save command history")

    def registerCommand( self, command, function, numparams = 0, usage = "", helptext = "" ):
        """Register a command"""
@@ -756,11 +742,11 @@ class BitBakeShell:
        try:
            function, numparams, usage, helptext = cmds[command]
        except KeyError:
-            print "SHELL: ERROR: '%s' command is not a valid command." % command
+            print("SHELL: ERROR: '%s' command is not a valid command." % command)
            self.myout.removeLast()
        else:
            if (numparams != -1) and (not len( params ) == numparams):
-                print "Usage: '%s'" % usage
+                print("Usage: '%s'" % usage)
                return

            result = function( self.commands, params )
@@ -775,7 +761,7 @@ class BitBakeShell:
                if not cmdline:
                    continue
                if "|" in cmdline:
-                    print "ERROR: '|' in startup file is not allowed. Ignoring line"
+                    print("ERROR: '|' in startup file is not allowed. Ignoring line")
                    continue
                self.commandQ.put( cmdline.strip() )

@@ -817,10 +803,10 @@ class BitBakeShell:
                                sys.stdout.write( pipe.fromchild.read() )
                        #
            except EOFError:
-                print
+                print()
                return
            except KeyboardInterrupt:
-                print
+                print()

 ##########################################################################
 # Start function - called from the BitBake command line utility
@@ -835,4 +821,4 @@ def start( aCooker ):
    bbshell.cleanup()

 if __name__ == "__main__":
-    print "SHELL: Sorry, this program should only be called by BitBake."
+    print("SHELL: Sorry, this program should only be called by BitBake.")
--- a/bitbake/lib/bb/siggen.py
+++ b/bitbake/lib/bb/siggen.py
@@ -0,0 +1,260 @@
+import hashlib
+import re
+
+try:
+    import cPickle as pickle
+except ImportError:
+    import pickle
+    bb.msg.note(1, bb.msg.domain.Cache, "Importing cPickle failed. Falling back to a very slow implementation.")
+
+def init(d, dumpsigs):
+    siggens = [obj for obj in globals().itervalues()
+                      if type(obj) is type and issubclass(obj, SignatureGenerator)]
+
+    desired = bb.data.getVar("BB_SIGNATURE_HANDLER", d, True) or "noop"
+    for sg in siggens:
+        if desired == sg.name:
+            return sg(d, dumpsigs)
+            break
+    else:
+        bb.error("Invalid signature generator '%s', using default 'noop' generator" % desired)
+        bb.error("Available generators: %s" % ", ".join(obj.name for obj in siggens))
+        return SignatureGenerator(d, dumpsigs)
+
+class SignatureGenerator(object):
+    """
+    """
+    name = "noop"
+
+    def __init__(self, data, dumpsigs):
+        return
+
+    def finalise(self, fn, d):
+        return
+
+class SignatureGeneratorBasic(SignatureGenerator):
+    """
+    """
+    name = "basic"
+
+    def __init__(self, data, dumpsigs):
+        self.basehash = {}
+        self.taskhash = {}
+        self.taskdeps = {}
+        self.runtaskdeps = {}
+        self.gendeps = {}
+        self.lookupcache = {}
+        self.basewhitelist = (data.getVar("BB_HASHBASE_WHITELIST", True) or "").split()
+        self.taskwhitelist = data.getVar("BB_HASHTASK_WHITELIST", True) or None
+
+        if self.taskwhitelist:
+            self.twl = re.compile(self.taskwhitelist)
+        else:
+            self.twl = None
+
+        self.dumpsigs = dumpsigs
+
+    def _build_data(self, fn, d):
+
+        taskdeps, gendeps = bb.data.generate_dependencies(d)
+
+        basehash = {}
+        lookupcache = {}
+
+        for task in taskdeps:
+            data = d.getVar(task, False)
+            lookupcache[task] = data
+            for dep in sorted(taskdeps[task]):
+                if dep in self.basewhitelist:
+                    continue
+                if dep in lookupcache:
+                    var = lookupcache[dep]
+                else:
+                    var = d.getVar(dep, False)
+                    lookupcache[dep] = var
+                if var:
+                    data = data + var
+            self.basehash[fn + "." + task] = hashlib.md5(data).hexdigest()
+            #bb.note("Hash for %s is %s" % (task, tashhash[task]))
+
+        if self.dumpsigs:
+            self.taskdeps[fn] = taskdeps
+            self.gendeps[fn] = gendeps
+            self.lookupcache[fn] = lookupcache
+
+        return taskdeps
+
+    def finalise(self, fn, d, variant):
+
+        if variant:
+            fn = "virtual:" + variant + ":" + fn
+
+        taskdeps = self._build_data(fn, d)
+
+        #Slow but can be useful for debugging mismatched basehashes
+        #for task in self.taskdeps[fn]:
+        #    self.dump_sigtask(fn, task, d.getVar("STAMP", True), False)
+
+        for task in taskdeps:
+            d.setVar("BB_BASEHASH_task-%s" % task, self.basehash[fn + "." + task])
+
+    def get_taskhash(self, fn, task, deps, dataCache):
+        k = fn + "." + task
+        data = dataCache.basetaskhash[k]
+        self.runtaskdeps[k] = deps
+        for dep in sorted(deps):
+            if self.twl and self.twl.search(dataCache.pkg_fn[fn]):
+                #bb.note("Skipping %s" % dep)
+                continue
+            if dep not in self.taskhash:
+                 bb.fatal("%s is not in taskhash, caller isn't calling in dependency order?", dep)
+            data = data + self.taskhash[dep]
+        h = hashlib.md5(data).hexdigest()
+        self.taskhash[k] = h
+        #d.setVar("BB_TASKHASH_task-%s" % task, taskhash[task])
+        return h
+
+    def set_taskdata(self, hashes, deps):
+        self.runtaskdeps = deps
+        self.taskhash = hashes
+
+    def dump_sigtask(self, fn, task, stampbase, runtime):
+        k = fn + "." + task
+        if runtime == "customfile":
+            sigfile = stampbase
+        elif runtime:
+            sigfile = stampbase + "." + task + ".sigdata" + "." + self.taskhash[k]
+        else:
+            sigfile = stampbase + "." + task + ".sigbasedata" + "." + self.basehash[k]
+
+        data = {}
+        data['basewhitelist'] = self.basewhitelist
+        data['taskwhitelist'] = self.taskwhitelist
+        data['taskdeps'] = self.taskdeps[fn][task]
+        data['basehash'] = self.basehash[k]
+        data['gendeps'] = {}
+        data['varvals'] = {}
+        data['varvals'][task] = self.lookupcache[fn][task]
+        for dep in self.taskdeps[fn][task]:
+            if dep in self.basewhitelist:
+                continue
+            data['gendeps'][dep] = self.gendeps[fn][dep]
+            data['varvals'][dep] = self.lookupcache[fn][dep]
+
+        if runtime:
+            data['runtaskdeps'] = self.runtaskdeps[k]
+            data['runtaskhashes'] = {}
+            for dep in data['runtaskdeps']:
+                data['runtaskhashes'][dep] = self.taskhash[dep]
+
+        p = pickle.Pickler(file(sigfile, "wb"), -1)
+        p.dump(data)
+
+    def dump_sigs(self, dataCache):
+        for fn in self.taskdeps:
+            for task in self.taskdeps[fn]:
+                k = fn + "." + task
+                if k not in self.taskhash:
+                    continue
+                if dataCache.basetaskhash[k] != self.basehash[k]:
+                    bb.error("Bitbake's cached basehash does not match the one we just generated!")
+                    bb.error("The mismatched hashes were %s and %s" % (dataCache.basetaskhash[k], self.basehash[k]))
+                self.dump_sigtask(fn, task, dataCache.stamp[fn], True)
+
+def dump_this_task(outfile, d):
+    fn = d.getVar("BB_FILENAME", True)
+    task = "do_" + d.getVar("BB_CURRENTTASK", True)
+    bb.parse.siggen.dump_sigtask(fn, task, outfile, "customfile")
+
+def compare_sigfiles(a, b):
+    p1 = pickle.Unpickler(file(a, "rb"))
+    a_data = p1.load()
+    p2 = pickle.Unpickler(file(b, "rb"))
+    b_data = p2.load()
+
+    #print "Checking"
+    #print str(a_data)
+    #print str(b_data)
+
+    def dict_diff(a, b):
+        sa = set(a.keys())
+        sb = set(b.keys())
+        common = sa & sb
+        changed = set()
+        for i in common:
+            if a[i] != b[i]:
+                changed.add(i)
+        added = sa - sb
+        removed = sb - sa
+        return changed, added, removed 
+
+    if 'basewhitelist' in a_data and a_data['basewhitelist'] != b_data['basewhitelist']:
+        print "basewhitelist changed from %s to %s" % (a_data['basewhitelist'], b_data['basewhitelist'])
+
+    if 'taskwhitelist' in a_data and a_data['taskwhitelist'] != b_data['taskwhitelist']:
+        print "taskwhitelist changed from %s to %s" % (a_data['taskwhitelist'], b_data['taskwhitelist'])
+
+    if a_data['taskdeps'] != b_data['taskdeps']:
+        print "Task dependencies changed from %s to %s" % (sorted(a_data['taskdeps']), sorted(b_data['taskdeps']))
+
+    if a_data['basehash'] != b_data['basehash']:
+        print "basehash changed from %s to %s" % (a_data['basehash'], b_data['basehash'])
+
+    changed, added, removed = dict_diff(a_data['gendeps'], b_data['gendeps'])
+    if changed:
+        for dep in changed:
+            print "List of dependencies for variable %s changed from %s to %s" % (dep, a_data['gendeps'][dep], b_data['gendeps'][dep])
+    if added:
+        for dep in added:
+            print "Dependency on variable %s was added" % (dep)
+    if removed:
+        for dep in removed:
+            print "Dependency on Variable %s was removed" % (dep)
+
+
+    changed, added, removed = dict_diff(a_data['varvals'], b_data['varvals'])
+    if changed:
+        for dep in changed:
+            print "Variable %s value changed from %s to %s" % (dep, a_data['varvals'][dep], b_data['varvals'][dep])
+    #if added:
+    #    print "Dependency on variable %s was added (value %s)" % (dep, b_data['gendeps'][dep])
+    #if removed:
+    #    print "Dependency on Variable %s was removed (value %s)" % (dep, a_data['gendeps'][dep])
+
+    if 'runtaskdeps' in a_data and 'runtaskdeps' in b_data and a_data['runtaskdeps'] != b_data['runtaskdeps']:
+        print "Tasks this task depends on changed from %s to %s" % (a_data['taskdeps'], b_data['taskdeps'])
+
+    if 'runtaskhashes' in a_data:
+        for dep in a_data['runtaskhashes']:
+            if a_data['runtaskhashes'][dep] != b_data['runtaskhashes'][dep]:
+                print "Hash for dependent task %s changed from %s to %s" % (dep, a_data['runtaskhashes'][dep], b_data['runtaskhashes'][dep])
+
+def dump_sigfile(a):
+    p1 = pickle.Unpickler(file(a, "rb"))
+    a_data = p1.load()
+
+    print "basewhitelist: %s" % (a_data['basewhitelist'])
+
+    print "taskwhitelist: %s" % (a_data['taskwhitelist'])
+
+    print "Task dependencies: %s" % (sorted(a_data['taskdeps']))
+
+    print "basehash: %s" % (a_data['basehash'])
+
+    for dep in a_data['gendeps']:
+        print "List of dependencies for variable %s is %s" % (dep, a_data['gendeps'][dep])
+
+    for dep in a_data['varvals']:
+        print "Variable %s value is %s" % (dep, a_data['varvals'][dep])
+
+    if 'runtaskdeps' in a_data:
+        print "Tasks this task depends on: %s" % (a_data['runtaskdeps'])
+
+    if 'runtaskhashes' in a_data:
+        for dep in a_data['runtaskhashes']:
+            print "Hash for dependent task %s is %s" % (dep, a_data['runtaskhashes'][dep])
+
+
+
+
+
--- a/bitbake/lib/bb/taskdata.py
+++ b/bitbake/lib/bb/taskdata.py
@@ -23,14 +23,26 @@ Task data collection and handling
 # with this program; if not, write to the Free Software Foundation, Inc.,
 # 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.

-from bb import data, fetch, event, mkdirhier, utils
-import bb, os
+import bb
+
+def re_match_strings(target, strings):
+    """
+    Whether or not the string 'target' matches
+    any one string of the strings which can be regular expression string
+    """
+    import re
+
+    for name in strings:
+        if (name==target or
+                re.search(name, target)!=None):
+            return True
+    return False

 class TaskData:
    """
    BitBake Task Data implementation
    """
-    def __init__(self, abort = True):
+    def __init__(self, abort = True, tryaltconfigs = False):
        self.build_names_index = []
        self.run_names_index = []
        self.fn_index = []
@@ -57,6 +69,7 @@ class TaskData:
        self.failed_fnids = []

        self.abort = abort
+        self.tryaltconfigs = tryaltconfigs

    def getbuild_id(self, name):
        """
@@ -71,7 +84,7 @@ class TaskData:

    def getrun_id(self, name):
        """
-        Return an ID number for the run target name. 
+        Return an ID number for the run target name.
        If it doesn't exist, create one.
        """
        if not name in self.run_names_index:
@@ -82,7 +95,7 @@ class TaskData:

    def getfn_id(self, name):
        """
-        Return an ID number for the filename. 
+        Return an ID number for the filename.
        If it doesn't exist, create one.
        """
        if not name in self.fn_index:
@@ -91,6 +104,16 @@ class TaskData:

        return self.fn_index.index(name)

+    def gettask_ids(self, fnid):
+        """
+        Return an array of the ID numbers matching a given fnid.
+        """
+        ids = []
+        if fnid in self.tasks_lookup:
+            for task in self.tasks_lookup[fnid]:
+                ids.append(self.tasks_lookup[fnid][task])
+        return ids
+
    def gettask_id(self, fn, task, create = True):
        """
        Return an ID number for the task matching fn and task.
@@ -124,7 +147,6 @@ class TaskData:
        Add tasks for a given fn to the database
        """

-        task_graph = dataCache.task_queues[fn]
        task_deps = dataCache.task_deps[fn]

        fnid = self.getfn_id(fn)
@@ -136,11 +158,11 @@ class TaskData:
        if fnid in self.tasks_fnid:
            return

-        for task in task_graph.allnodes():
+        for task in task_deps['tasks']:

            # Work out task dependencies
            parentids = []
-            for dep in task_graph.getparents(task):
+            for dep in task_deps['parents'][task]:
                parentid = self.gettask_id(fn, dep)
                parentids.append(parentid)
            taskid = self.gettask_id(fn, task)
@@ -149,9 +171,11 @@ class TaskData:
            # Touch all intertask dependencies
            if 'depends' in task_deps and task in task_deps['depends']:
                ids = []
-                for dep in task_deps['depends'][task].split(" "):
+                for dep in task_deps['depends'][task].split():
                    if dep:
-                        ids.append(str(self.getbuild_id(dep.split(":")[0])) + ":" + dep.split(":")[1])
+                        if ":" not in dep:
+                            bb.msg.fatal(bb.msg.domain.TaskData, "Error, dependency %s does not contain ':' character\n. Task 'depends' should be specified in the form 'packagename:task'" % (dep, fn))
+                        ids.append(((self.getbuild_id(dep.split(":")[0])), dep.split(":")[1]))
                self.tasks_idepends[taskid].extend(ids)

        # Work out build dependencies
@@ -168,11 +192,11 @@ class TaskData:
            rdepends = dataCache.rundeps[fn]
            rrecs = dataCache.runrecs[fn]
            for package in rdepends:
-                for rdepend in rdepends[package]:
+                for rdepend in bb.utils.explode_deps(rdepends[package]):
                    bb.msg.debug(2, bb.msg.domain.TaskData, "Added runtime dependency %s for %s" % (rdepend, fn))
                    rdependids[self.getrun_id(rdepend)] = None
            for package in rrecs:
-                for rdepend in rrecs[package]:
+                for rdepend in bb.utils.explode_deps(rrecs[package]):
                    bb.msg.debug(2, bb.msg.domain.TaskData, "Added runtime recommendation %s for %s" % (rdepend, fn))
                    rdependids[self.getrun_id(rdepend)] = None
            self.rdepids[fnid] = rdependids.keys()
@@ -247,12 +271,12 @@ class TaskData:

    def get_unresolved_build_targets(self, dataCache):
        """
-        Return a list of build targets who's providers 
+        Return a list of build targets who's providers
        are unknown.
        """
        unresolved = []
        for target in self.build_names_index:
-            if target in dataCache.ignored_dependencies:
+            if re_match_strings(target, dataCache.ignored_dependencies):
                continue
            if self.build_names_index.index(target) in self.failed_deps:
                continue
@@ -262,12 +286,12 @@ class TaskData:

    def get_unresolved_run_targets(self, dataCache):
        """
-        Return a list of runtime targets who's providers 
+        Return a list of runtime targets who's providers
        are unknown.
        """
        unresolved = []
        for target in self.run_names_index:
-            if target in dataCache.ignored_dependencies:
+            if re_match_strings(target, dataCache.ignored_dependencies):
                continue
            if self.run_names_index.index(target) in self.failed_rdeps:
                continue
@@ -280,7 +304,7 @@ class TaskData:
        Return a list of providers of item
        """
        targetid = self.getbuild_id(item)
-   
+
        return self.build_targets[targetid]

    def get_dependees(self, itemid):
@@ -330,26 +354,23 @@ class TaskData:
            self.add_provider_internal(cfgData, dataCache, item)
        except bb.providers.NoProvider:
            if self.abort:
-                bb.msg.error(bb.msg.domain.Provider, "No providers of build target %s (for %s)" % (item, self.get_dependees_str(item)))
                raise
-            targetid = self.getbuild_id(item)
-            self.remove_buildtarget(targetid)
+            self.remove_buildtarget(self.getbuild_id(item))

        self.mark_external_target(item)

    def add_provider_internal(self, cfgData, dataCache, item):
        """
        Add the providers of item to the task data
-        Mark entries were specifically added externally as against dependencies 
+        Mark entries were specifically added externally as against dependencies
        added internally during dependency resolution
        """

-        if item in dataCache.ignored_dependencies:
+        if re_match_strings(item, dataCache.ignored_dependencies):
            return

        if not item in dataCache.providers:
-            bb.msg.note(2, bb.msg.domain.Provider, "No providers of build target %s (for %s)" % (item, self.get_dependees_str(item)))
-            bb.event.fire(bb.event.NoProvider(item, cfgData))
+            bb.event.fire(bb.event.NoProvider(item, dependees=self.get_rdependees_str(item)), cfgData)
            raise bb.providers.NoProvider(item)

        if self.have_build_target(item):
@@ -357,41 +378,19 @@ class TaskData:

        all_p = dataCache.providers[item]

-        eligible = bb.providers.filterProviders(all_p, item, cfgData, dataCache)
-
-        for p in eligible:
-            fnid = self.getfn_id(p)
-            if fnid in self.failed_fnids:
-                eligible.remove(p)
+        eligible, foundUnique = bb.providers.filterProviders(all_p, item, cfgData, dataCache)
+        eligible = [p for p in eligible if not self.getfn_id(p) in self.failed_fnids]

        if not eligible:
-            bb.msg.note(2, bb.msg.domain.Provider, "No providers of build target %s after filtering (for %s)" % (item, self.get_dependees_str(item)))
-            bb.event.fire(bb.event.NoProvider(item, cfgData))
+            bb.event.fire(bb.event.NoProvider(item, dependees=self.get_dependees_str(item)), cfgData)
            raise bb.providers.NoProvider(item)

-        prefervar = bb.data.getVar('PREFERRED_PROVIDER_%s' % item, cfgData, 1)
-        if prefervar:
-            dataCache.preferred[item] = prefervar
-
-        discriminated = False
-        if item in dataCache.preferred:
-            for p in eligible:
-                pn = dataCache.pkg_fn[p]
-                if dataCache.preferred[item] == pn:
-                    bb.msg.note(2, bb.msg.domain.Provider, "selecting %s to satisfy %s due to PREFERRED_PROVIDERS" % (pn, item))
-                    eligible.remove(p)
-                    eligible = [p] + eligible
-                    discriminated = True
-                    break
-
-        if len(eligible) > 1 and discriminated == False:
+        if len(eligible) > 1 and foundUnique == False:
            if item not in self.consider_msgs_cache:
                providers_list = []
                for fn in eligible:
                    providers_list.append(dataCache.pkg_fn[fn])
-                bb.msg.note(1, bb.msg.domain.Provider, "multiple providers are available for %s (%s);" % (item, ", ".join(providers_list)))
-                bb.msg.note(1, bb.msg.domain.Provider, "consider defining PREFERRED_PROVIDER_%s" % item)
-                bb.event.fire(bb.event.MultipleProviders(item,providers_list,cfgData))
+                bb.event.fire(bb.event.MultipleProviders(item, providers_list), cfgData)
            self.consider_msgs_cache.append(item)

        for fn in eligible:
@@ -411,7 +410,7 @@ class TaskData:
        (takes item names from RDEPENDS/PACKAGES namespace)
        """

-        if item in dataCache.ignored_dependencies:
+        if re_match_strings(item, dataCache.ignored_dependencies):
            return

        if self.have_runtime_target(item):
@@ -420,54 +419,30 @@ class TaskData:
        all_p = bb.providers.getRuntimeProviders(dataCache, item)

        if not all_p:
-            bb.msg.error(bb.msg.domain.Provider, "No providers of runtime build target %s (for %s)" % (item, self.get_rdependees_str(item)))
-            bb.event.fire(bb.event.NoProvider(item, cfgData, runtime=True))
+            bb.event.fire(bb.event.NoProvider(item, runtime=True, dependees=self.get_rdependees_str(item)), cfgData)
            raise bb.providers.NoRProvider(item)

-        eligible = bb.providers.filterProviders(all_p, item, cfgData, dataCache)
-
-        for p in eligible:
-            fnid = self.getfn_id(p)
-            if fnid in self.failed_fnids:
-                eligible.remove(p)
+        eligible, numberPreferred = bb.providers.filterProvidersRunTime(all_p, item, cfgData, dataCache)
+        eligible = [p for p in eligible if not self.getfn_id(p) in self.failed_fnids]

        if not eligible:
-            bb.msg.error(bb.msg.domain.Provider, "No providers of runtime build target %s after filtering (for %s)" % (item, self.get_rdependees_str(item)))
-            bb.event.fire(bb.event.NoProvider(item, cfgData, runtime=True))
+            bb.event.fire(bb.event.NoProvider(item, runtime=True, dependees=self.get_rdependees_str(item)), cfgData)
            raise bb.providers.NoRProvider(item)

-        # Should use dataCache.preferred here?
-        preferred = []
-        for p in eligible:
-            pn = dataCache.pkg_fn[p]
-            provides = dataCache.pn_provides[pn]
-            for provide in provides:
-                prefervar = bb.data.getVar('PREFERRED_PROVIDER_%s' % provide, cfgData, 1)
-                if prefervar == pn:
-                    bb.msg.note(2, bb.msg.domain.Provider, "selecting %s to satisfy runtime %s due to PREFERRED_PROVIDERS" % (pn, item))
-                    eligible.remove(p)
-                    eligible = [p] + eligible
-                    preferred.append(p)
-                    break
-
-        if len(eligible) > 1 and len(preferred) == 0:
+        if len(eligible) > 1 and numberPreferred == 0:
            if item not in self.consider_msgs_cache:
                providers_list = []
                for fn in eligible:
                    providers_list.append(dataCache.pkg_fn[fn])
-                bb.msg.note(2, bb.msg.domain.Provider, "multiple providers are available for runtime %s (%s);" % (item, ", ".join(providers_list)))
-                bb.msg.note(2, bb.msg.domain.Provider, "consider defining a PREFERRED_PROVIDER entry to match runtime %s" % item)
-                bb.event.fire(bb.event.MultipleProviders(item,providers_list, cfgData, runtime=True))
+                bb.event.fire(bb.event.MultipleProviders(item, providers_list, runtime=True), cfgData)
            self.consider_msgs_cache.append(item)

-        if len(preferred) > 1:
+        if numberPreferred > 1:
            if item not in self.consider_msgs_cache:
                providers_list = []
-                for fn in preferred:
+                for fn in eligible:
                    providers_list.append(dataCache.pkg_fn[fn])
-                bb.msg.note(2, bb.msg.domain.Provider, "multiple preferred providers are available for runtime %s (%s);" % (item, ", ".join(providers_list)))
-                bb.msg.note(2, bb.msg.domain.Provider, "consider defining only one PREFERRED_PROVIDER entry to match runtime %s" % item)
-                bb.event.fire(bb.event.MultipleProviders(item,providers_list, cfgData, runtime=True))
+                bb.event.fire(bb.event.MultipleProviders(item, providers_list, runtime=True), cfgData)
            self.consider_msgs_cache.append(item)

        # run through the list until we find one that we can build
@@ -475,61 +450,79 @@ class TaskData:
            fnid = self.getfn_id(fn)
            if fnid in self.failed_fnids:
                continue
-            bb.msg.debug(2, bb.msg.domain.Provider, "adding %s to satisfy runtime %s" % (fn, item))
+            bb.msg.debug(2, bb.msg.domain.Provider, "adding '%s' to satisfy runtime '%s'" % (fn, item))
            self.add_runtime_target(fn, item)
            self.add_tasks(fn, dataCache)

-    def fail_fnid(self, fnid):
+    def fail_fnid(self, fnid, missing_list = []):
        """
        Mark a file as failed (unbuildable)
        Remove any references from build and runtime provider lists
+
+        missing_list, A list of missing requirements for this target
        """
        if fnid in self.failed_fnids:
            return
-        bb.msg.debug(1, bb.msg.domain.Provider, "Removing failed file %s" % self.fn_index[fnid])
+        bb.msg.debug(1, bb.msg.domain.Provider, "File '%s' is unbuildable, removing..." % self.fn_index[fnid])
        self.failed_fnids.append(fnid)
        for target in self.build_targets:
            if fnid in self.build_targets[target]:
                self.build_targets[target].remove(fnid)
                if len(self.build_targets[target]) == 0:
-                    self.remove_buildtarget(target)
+                    self.remove_buildtarget(target, missing_list)
        for target in self.run_targets:
            if fnid in self.run_targets[target]:
                self.run_targets[target].remove(fnid)
                if len(self.run_targets[target]) == 0:
-                    self.remove_runtarget(target)
+                    self.remove_runtarget(target, missing_list)

-    def remove_buildtarget(self, targetid):
+    def remove_buildtarget(self, targetid, missing_list = []):
        """
        Mark a build target as failed (unbuildable)
        Trigger removal of any files that have this as a dependency
        """
-        bb.msg.note(2, bb.msg.domain.Provider, "Removing failed build target %s" % self.build_names_index[targetid])
+        if not missing_list:
+            missing_list = [self.build_names_index[targetid]]
+        else:
+            missing_list = [self.build_names_index[targetid]] + missing_list
+        bb.msg.note(2, bb.msg.domain.Provider, "Target '%s' is unbuildable, removing...\nMissing or unbuildable dependency chain was: %s" % (self.build_names_index[targetid], missing_list))
        self.failed_deps.append(targetid)
        dependees = self.get_dependees(targetid)
        for fnid in dependees:
-            self.fail_fnid(fnid)
-        if self.abort and targetid in self.external_targets:
-            bb.msg.error(bb.msg.domain.Provider, "No buildable providers available for required build target %s" % self.build_names_index[targetid])
-            raise bb.providers.NoProvider
+            self.fail_fnid(fnid, missing_list)
+        for taskid in range(len(self.tasks_idepends)):
+            idepends = self.tasks_idepends[taskid]
+            for (idependid, idependtask) in idepends:
+                if idependid == targetid:
+                    self.fail_fnid(self.tasks_fnid[taskid], missing_list)

-    def remove_runtarget(self, targetid):
+        if self.abort and targetid in self.external_targets:
+            target = self.build_names_index[targetid]
+            bb.msg.error(bb.msg.domain.Provider, "Required build target '%s' has no buildable providers.\nMissing or unbuildable dependency chain was: %s" % (target, missing_list))
+            raise bb.providers.NoProvider(target)
+
+    def remove_runtarget(self, targetid, missing_list = []):
        """
        Mark a run target as failed (unbuildable)
        Trigger removal of any files that have this as a dependency
        """
-        bb.msg.note(1, bb.msg.domain.Provider, "Removing failed runtime build target %s" % self.run_names_index[targetid])
+        if not missing_list:
+            missing_list = [self.run_names_index[targetid]]
+        else:
+            missing_list = [self.run_names_index[targetid]] + missing_list
+
+        bb.msg.note(1, bb.msg.domain.Provider, "Runtime target '%s' is unbuildable, removing...\nMissing or unbuildable dependency chain was: %s" % (self.run_names_index[targetid], missing_list))
        self.failed_rdeps.append(targetid)
        dependees = self.get_rdependees(targetid)
        for fnid in dependees:
-            self.fail_fnid(fnid)
+            self.fail_fnid(fnid, missing_list)

    def add_unresolved(self, cfgData, dataCache):
        """
        Resolve all unresolved build and runtime targets
        """
-        bb.msg.note(1, bb.msg.domain.TaskData, "Resolving missing task queue dependencies")
-        while 1:
+        bb.msg.note(1, bb.msg.domain.TaskData, "Resolving any missing task queue dependencies")
+        while True:
            added = 0
            for target in self.get_unresolved_build_targets(dataCache):
                try:
@@ -546,7 +539,7 @@ class TaskData:
                    added = added + 1
                except bb.providers.NoRProvider:
                    self.remove_runtarget(self.getrun_id(target))
-            bb.msg.debug(1, bb.msg.domain.TaskData, "Resolved " + str(added) + " extra dependecies")
+            bb.msg.debug(1, bb.msg.domain.TaskData, "Resolved " + str(added) + " extra dependencies")
            if added == 0:
                break
        # self.dump_data()
@@ -557,23 +550,38 @@ class TaskData:
        """
        bb.msg.debug(3, bb.msg.domain.TaskData, "build_names:")
        bb.msg.debug(3, bb.msg.domain.TaskData, ", ".join(self.build_names_index))
+
        bb.msg.debug(3, bb.msg.domain.TaskData, "run_names:")
        bb.msg.debug(3, bb.msg.domain.TaskData, ", ".join(self.run_names_index))
+
        bb.msg.debug(3, bb.msg.domain.TaskData, "build_targets:")
-        for target in self.build_targets.keys():
-            bb.msg.debug(3, bb.msg.domain.TaskData, " %s: %s" % (self.build_names_index[target], self.build_targets[target]))
+        for buildid in range(len(self.build_names_index)):
+            target = self.build_names_index[buildid]
+            targets = "None"
+            if buildid in self.build_targets:
+                targets = self.build_targets[buildid]
+            bb.msg.debug(3, bb.msg.domain.TaskData, " (%s)%s: %s" % (buildid, target, targets))
+
        bb.msg.debug(3, bb.msg.domain.TaskData, "run_targets:")
-        for target in self.run_targets.keys():
-            bb.msg.debug(3, bb.msg.domain.TaskData, " %s: %s" % (self.run_names_index[target], self.run_targets[target]))
+        for runid in range(len(self.run_names_index)):
+            target = self.run_names_index[runid]
+            targets = "None"
+            if runid in self.run_targets:
+                targets = self.run_targets[runid]
+            bb.msg.debug(3, bb.msg.domain.TaskData, " (%s)%s: %s" % (runid, target, targets))
+
        bb.msg.debug(3, bb.msg.domain.TaskData, "tasks:")
        for task in range(len(self.tasks_name)):
            bb.msg.debug(3, bb.msg.domain.TaskData, " (%s)%s - %s: %s" % (
-                task, 
-                self.fn_index[self.tasks_fnid[task]], 
-                self.tasks_name[task], 
+                task,
+                self.fn_index[self.tasks_fnid[task]],
+                self.tasks_name[task],
                self.tasks_tdepends[task]))
-        bb.msg.debug(3, bb.msg.domain.TaskData, "runtime ids (per fn):")
+
+        bb.msg.debug(3, bb.msg.domain.TaskData, "dependency ids (per fn):")
+        for fnid in self.depids:
+            bb.msg.debug(3, bb.msg.domain.TaskData, " %s %s: %s" % (fnid, self.fn_index[fnid], self.depids[fnid]))
+
+        bb.msg.debug(3, bb.msg.domain.TaskData, "runtime dependency ids (per fn):")
        for fnid in self.rdepids:
            bb.msg.debug(3, bb.msg.domain.TaskData, " %s %s: %s" % (fnid, self.fn_index[fnid], self.rdepids[fnid]))
-
-
--- a/bitbake/lib/bb/ui/init.py
+++ b/bitbake/lib/bb/ui/init.py
@@ -0,0 +1,17 @@
+#
+# BitBake UI Implementation
+#
+# Copyright (C) 2006-2007 Richard Purdie
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License version 2 as
+# published by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License along
+# with this program; if not, write to the Free Software Foundation, Inc.,
+# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
--- a/bitbake/lib/bb/ui/crumbs/init.py
+++ b/bitbake/lib/bb/ui/crumbs/init.py
@@ -0,0 +1,17 @@
+#
+# BitBake UI Implementation
+#
+# Copyright (C) 2006-2007 Richard Purdie
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License version 2 as
+# published by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License along
+# with this program; if not, write to the Free Software Foundation, Inc.,
+# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
--- a/bitbake/lib/bb/ui/crumbs/buildmanager.py
+++ b/bitbake/lib/bb/ui/crumbs/buildmanager.py
@@ -0,0 +1,455 @@
+#
+# BitBake Graphical GTK User Interface
+#
+# Copyright (C) 2008        Intel Corporation
+#
+# Authored by Rob Bradford <rob@linux.intel.com>
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License version 2 as
+# published by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License along
+# with this program; if not, write to the Free Software Foundation, Inc.,
+# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+
+import gtk
+import gobject
+import threading
+import os
+import datetime
+import time
+
+class BuildConfiguration:
+    """ Represents a potential *or* historic *or* concrete build. It
+    encompasses all the things that we need to tell bitbake to do to make it
+    build what we want it to build.
+
+    It also stored the metadata URL and the set of possible machines (and the
+    distros / images / uris for these. Apart from the metdata URL these are
+    not serialised to file (since they may be transient). In some ways this
+    functionality might be shifted to the loader class."""
+
+    def __init__ (self):
+        self.metadata_url = None
+
+        # Tuple of (distros, image, urls)
+        self.machine_options = {}
+
+        self.machine = None
+        self.distro = None
+        self.image = None
+        self.urls = []
+        self.extra_urls = []
+        self.extra_pkgs = []
+
+    def get_machines_model (self):
+        model = gtk.ListStore (gobject.TYPE_STRING)
+        for machine in self.machine_options.keys():
+            model.append ([machine])
+
+        return model
+
+    def get_distro_and_images_models (self, machine):
+        distro_model = gtk.ListStore (gobject.TYPE_STRING)
+
+        for distro in self.machine_options[machine][0]:
+            distro_model.append ([distro])
+
+        image_model = gtk.ListStore (gobject.TYPE_STRING)
+
+        for image in self.machine_options[machine][1]:
+            image_model.append ([image])
+
+        return (distro_model, image_model)
+
+    def get_repos (self):
+        self.urls = self.machine_options[self.machine][2]
+        return self.urls
+
+    # It might be a lot lot better if we stored these in like, bitbake conf
+    # file format.
+    @staticmethod
+    def load_from_file (filename):
+
+        conf = BuildConfiguration()
+        with open(filename, "r") as f:
+            for line in f:
+                data = line.split (";")[1]
+                if (line.startswith ("metadata-url;")):
+                    conf.metadata_url = data.strip()
+                    continue
+                if (line.startswith ("url;")):
+                    conf.urls += [data.strip()]
+                    continue
+                if (line.startswith ("extra-url;")):
+                    conf.extra_urls += [data.strip()]
+                    continue
+                if (line.startswith ("machine;")):
+                    conf.machine = data.strip()
+                    continue
+                if (line.startswith ("distribution;")):
+                    conf.distro = data.strip()
+                    continue
+                if (line.startswith ("image;")):
+                    conf.image = data.strip()
+                    continue
+
+        return conf
+
+    # Serialise to a file. This is part of the build process and we use this
+    # to be able to repeat a given build (using the same set of parameters)
+    # but also so that we can include the details of the image / machine /
+    # distro in the build manager tree view.
+    def write_to_file (self, filename):
+        f = open (filename, "w")
+
+        lines = []
+
+        if (self.metadata_url):
+            lines += ["metadata-url;%s\n" % (self.metadata_url)]
+
+        for url in self.urls:
+            lines += ["url;%s\n" % (url)]
+
+        for url in self.extra_urls:
+            lines += ["extra-url;%s\n" % (url)]
+
+        if (self.machine):
+            lines += ["machine;%s\n" % (self.machine)]
+
+        if (self.distro):
+            lines += ["distribution;%s\n" % (self.distro)]
+
+        if (self.image):
+            lines += ["image;%s\n" % (self.image)]
+
+        f.writelines (lines)
+        f.close ()
+
+class BuildResult(gobject.GObject):
+    """ Represents an historic build. Perhaps not successful. But it includes
+    things such as the files that are in the directory (the output from the
+    build) as well as a deserialised BuildConfiguration file that is stored in
+    ".conf" in the directory for the build.
+
+    This is GObject so that it can be included in the TreeStore."""
+
+    (STATE_COMPLETE, STATE_FAILED, STATE_ONGOING) = \
+        (0, 1, 2)
+
+    def __init__ (self, parent, identifier):
+        gobject.GObject.__init__ (self)
+        self.date = None
+
+        self.files = []
+        self.status = None
+        self.identifier = identifier
+        self.path = os.path.join (parent, identifier)
+
+        # Extract the date, since the directory name is of the
+        # format build-<year><month><day>-<ordinal> we can easily
+        # pull it out.
+        # TODO: Better to stat a file?
+        (_, date, revision) = identifier.split ("-")
+        print(date)
+
+        year = int (date[0:4])
+        month = int (date[4:6])
+        day = int (date[6:8])
+
+        self.date = datetime.date (year, month, day)
+
+        self.conf = None
+
+        # By default builds are STATE_FAILED unless we find a "complete" file
+        # in which case they are STATE_COMPLETE
+        self.state = BuildResult.STATE_FAILED
+        for file in os.listdir (self.path):
+            if (file.startswith (".conf")):
+                conffile = os.path.join (self.path, file)
+                self.conf = BuildConfiguration.load_from_file (conffile)
+            elif (file.startswith ("complete")):
+                self.state = BuildResult.STATE_COMPLETE
+            else:
+                self.add_file (file)
+
+    def add_file (self, file):
+        # Just add the file for now. Don't care about the type.
+        self.files += [(file, None)]
+
+class BuildManagerModel (gtk.TreeStore):
+    """ Model for the BuildManagerTreeView. This derives from gtk.TreeStore
+    but it abstracts nicely what the columns mean and the setup of the columns
+    in the model. """
+
+    (COL_IDENT, COL_DESC, COL_MACHINE, COL_DISTRO, COL_BUILD_RESULT, COL_DATE, COL_STATE) = \
+        (0, 1, 2, 3, 4, 5, 6)
+
+    def __init__ (self):
+        gtk.TreeStore.__init__ (self,
+            gobject.TYPE_STRING,
+            gobject.TYPE_STRING,
+            gobject.TYPE_STRING,
+            gobject.TYPE_STRING,
+            gobject.TYPE_OBJECT,
+            gobject.TYPE_INT64,
+            gobject.TYPE_INT)
+
+class BuildManager (gobject.GObject):
+    """ This class manages the historic builds that have been found in the
+    "results" directory but is also used for starting a new build."""
+
+    __gsignals__ = {
+        'population-finished' : (gobject.SIGNAL_RUN_LAST,
+                                 gobject.TYPE_NONE,
+                                 ()),
+        'populate-error' : (gobject.SIGNAL_RUN_LAST,
+                            gobject.TYPE_NONE,
+                            ())
+    }
+
+    def update_build_result (self, result, iter):
+        # Convert the date into something we can sort by.
+        date = long (time.mktime (result.date.timetuple()))
+
+        # Add a top level entry for the build
+
+        self.model.set (iter,
+            BuildManagerModel.COL_IDENT, result.identifier,
+            BuildManagerModel.COL_DESC, result.conf.image,
+            BuildManagerModel.COL_MACHINE, result.conf.machine,
+            BuildManagerModel.COL_DISTRO, result.conf.distro,
+            BuildManagerModel.COL_BUILD_RESULT, result,
+            BuildManagerModel.COL_DATE, date,
+            BuildManagerModel.COL_STATE, result.state)
+
+        # And then we use the files in the directory as the children for the
+        # top level iter.
+        for file in result.files:
+            self.model.append (iter, (None, file[0], None, None, None, date, -1))
+
+    # This function is called as an idle by the BuildManagerPopulaterThread
+    def add_build_result (self, result):
+        gtk.gdk.threads_enter()
+        self.known_builds += [result]
+
+        self.update_build_result (result, self.model.append (None))
+
+        gtk.gdk.threads_leave()
+
+    def notify_build_finished (self):
+        # This is a bit of a hack. If we have a running build running then we
+        # will have a row in the model in STATE_ONGOING. Find it and make it
+        # as if it was a proper historic build (well, it is completed now....)
+
+        # We need to use the iters here rather than the Python iterator
+        # interface to the model since we need to pass it into
+        # update_build_result
+
+        iter = self.model.get_iter_first()
+
+        while (iter):
+            (ident, state) = self.model.get(iter,
+                BuildManagerModel.COL_IDENT,
+                BuildManagerModel.COL_STATE)
+
+            if state == BuildResult.STATE_ONGOING:
+                result = BuildResult (self.results_directory, ident)
+                self.update_build_result (result, iter)
+            iter = self.model.iter_next(iter)
+
+    def notify_build_succeeded (self):
+        # Write the "complete" file so that when we create the BuildResult
+        # object we put into the model
+
+        complete_file_path = os.path.join (self.cur_build_directory, "complete")
+        f = file (complete_file_path, "w")
+        f.close()
+        self.notify_build_finished()
+
+    def notify_build_failed (self):
+        # Without a "complete" file then this will mark the build as failed:
+        self.notify_build_finished()
+
+    # This function is called as an idle
+    def emit_population_finished_signal (self):
+        gtk.gdk.threads_enter()
+        self.emit ("population-finished")
+        gtk.gdk.threads_leave()
+
+    class BuildManagerPopulaterThread (threading.Thread):
+        def __init__ (self, manager, directory):
+            threading.Thread.__init__ (self)
+            self.manager = manager
+            self.directory = directory
+
+        def run (self):
+            # For each of the "build-<...>" directories ..
+
+            if os.path.exists (self.directory):
+                for directory in os.listdir (self.directory):
+
+                    if not directory.startswith ("build-"):
+                        continue
+
+                    build_result = BuildResult (self.directory, directory)
+                    self.manager.add_build_result (build_result)
+
+            gobject.idle_add (BuildManager.emit_population_finished_signal,
+                self.manager)
+
+    def __init__ (self, server, results_directory):
+        gobject.GObject.__init__ (self)
+
+        # The builds that we've found from walking the result directory
+        self.known_builds = []
+
+        # Save out the bitbake server, we need this for issuing commands to
+        # the cooker:
+        self.server = server
+
+        # The TreeStore that we use
+        self.model = BuildManagerModel ()
+
+        # The results directory is where we create (and look for) the
+        # build-<xyz>-<n> directories. We need to populate ourselves from
+        # directory
+        self.results_directory = results_directory
+        self.populate_from_directory (self.results_directory)
+
+    def populate_from_directory (self, directory):
+        thread = BuildManager.BuildManagerPopulaterThread (self, directory)
+        thread.start()
+
+    # Come up with the name for the next build ident by combining "build-"
+    # with the date formatted as yyyymmdd and then an ordinal. We do this by
+    # an optimistic algorithm incrementing the ordinal if we find that it
+    # already exists.
+    def get_next_build_ident (self):
+        today = datetime.date.today ()
+        datestr = str (today.year) + str (today.month) + str (today.day)
+
+        revision = 0
+        test_name = "build-%s-%d" % (datestr, revision)
+        test_path = os.path.join (self.results_directory, test_name)
+
+        while (os.path.exists (test_path)):
+            revision += 1
+            test_name = "build-%s-%d" % (datestr, revision)
+            test_path = os.path.join (self.results_directory, test_name)
+
+        return test_name
+
+    # Take a BuildConfiguration and then try and build it based on the
+    # parameters of that configuration. S
+    def do_build (self, conf):
+        server = self.server
+
+        # Work out the build directory. Note we actually create the
+        # directories here since we need to write the ".conf" file. Otherwise
+        # we could have relied on bitbake's builder thread to actually make
+        # the directories as it proceeds with the build.
+        ident = self.get_next_build_ident ()
+        build_directory = os.path.join (self.results_directory,
+            ident)
+        self.cur_build_directory = build_directory
+        os.makedirs (build_directory)
+
+        conffile = os.path.join (build_directory, ".conf")
+        conf.write_to_file (conffile)
+
+        # Add a row to the model representing this ongoing build. It's kinda a
+        # fake entry. If this build completes or fails then this gets updated
+        # with the real stuff like the historic builds
+        date = long (time.time())
+        self.model.append (None, (ident, conf.image, conf.machine, conf.distro,
+            None, date, BuildResult.STATE_ONGOING))
+        try:
+            server.runCommand(["setVariable", "BUILD_IMAGES_FROM_FEEDS", 1])
+            server.runCommand(["setVariable", "MACHINE", conf.machine])
+            server.runCommand(["setVariable", "DISTRO", conf.distro])
+            server.runCommand(["setVariable", "PACKAGE_CLASSES", "package_ipk"])
+            server.runCommand(["setVariable", "BBFILES", \
+              """${OEROOT}/meta/packages/*/*.bb ${OEROOT}/meta-moblin/packages/*/*.bb"""])
+            server.runCommand(["setVariable", "TMPDIR", "${OEROOT}/build/tmp"])
+            server.runCommand(["setVariable", "IPK_FEED_URIS", \
+                " ".join(conf.get_repos())])
+            server.runCommand(["setVariable", "DEPLOY_DIR_IMAGE",
+                build_directory])
+            server.runCommand(["buildTargets", [conf.image], "rootfs"])
+
+        except Exception as e:
+            print(e)
+
+class BuildManagerTreeView (gtk.TreeView):
+    """ The tree view for the build manager. This shows the historic builds
+    and so forth. """
+
+    # We use this function to control what goes in the cell since we store
+    # the date in the model as seconds since the epoch (for sorting) and so we
+    # need to make it human readable.
+    def date_format_custom_cell_data_func (self, col, cell, model, iter):
+        date = model.get (iter, BuildManagerModel.COL_DATE)[0]
+        datestr = time.strftime("%A %d %B %Y", time.localtime(date))
+        cell.set_property ("text", datestr)
+
+    # This format function controls what goes in the cell. We use this to map
+    # the integer state to a string and also to colourise the text
+    def state_format_custom_cell_data_fun (self, col, cell, model, iter):
+        state = model.get (iter, BuildManagerModel.COL_STATE)[0]
+
+        if (state == BuildResult.STATE_ONGOING):
+            cell.set_property ("text", "Active")
+            cell.set_property ("foreground", "#000000")
+        elif (state == BuildResult.STATE_FAILED):
+            cell.set_property ("text", "Failed")
+            cell.set_property ("foreground", "#ff0000")
+        elif (state == BuildResult.STATE_COMPLETE):
+            cell.set_property ("text", "Complete")
+            cell.set_property ("foreground", "#00ff00")
+        else:
+            cell.set_property ("text", "")
+
+    def __init__ (self):
+        gtk.TreeView.__init__(self)
+
+        # Misc descriptiony thing
+        renderer = gtk.CellRendererText ()
+        col = gtk.TreeViewColumn (None, renderer,
+            text=BuildManagerModel.COL_DESC)
+        self.append_column (col)
+
+        # Machine
+        renderer = gtk.CellRendererText ()
+        col = gtk.TreeViewColumn ("Machine", renderer,
+            text=BuildManagerModel.COL_MACHINE)
+        self.append_column (col)
+
+        # distro
+        renderer = gtk.CellRendererText ()
+        col = gtk.TreeViewColumn ("Distribution", renderer,
+            text=BuildManagerModel.COL_DISTRO)
+        self.append_column (col)
+
+        # date (using a custom function for formatting the cell contents it
+        # takes epoch -> human readable string)
+        renderer = gtk.CellRendererText ()
+        col = gtk.TreeViewColumn ("Date", renderer,
+            text=BuildManagerModel.COL_DATE)
+        self.append_column (col)
+        col.set_cell_data_func (renderer,
+            self.date_format_custom_cell_data_func)
+
+        # For status.
+        renderer = gtk.CellRendererText ()
+        col = gtk.TreeViewColumn ("Status", renderer,
+            text = BuildManagerModel.COL_STATE)
+        self.append_column (col)
+        col.set_cell_data_func (renderer,
+            self.state_format_custom_cell_data_fun)
--- a/bitbake/lib/bb/ui/crumbs/puccho.glade
+++ b/bitbake/lib/bb/ui/crumbs/puccho.glade
@@ -0,0 +1,606 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<!DOCTYPE glade-interface SYSTEM "glade-2.0.dtd">
+<!--Generated with glade3 3.4.5 on Mon Nov 10 12:24:12 2008 -->
+<glade-interface>
+  <widget class="GtkDialog" id="build_dialog">
+    <property name="title" translatable="yes">Start a build</property>
+    <property name="window_position">GTK_WIN_POS_CENTER_ON_PARENT</property>
+    <property name="type_hint">GDK_WINDOW_TYPE_HINT_DIALOG</property>
+    <property name="has_separator">False</property>
+    <child internal-child="vbox">
+      <widget class="GtkVBox" id="dialog-vbox1">
+        <property name="visible">True</property>
+        <property name="spacing">2</property>
+        <child>
+          <widget class="GtkTable" id="build_table">
+            <property name="visible">True</property>
+            <property name="border_width">6</property>
+            <property name="n_rows">7</property>
+            <property name="n_columns">3</property>
+            <property name="column_spacing">5</property>
+            <property name="row_spacing">6</property>
+            <child>
+              <widget class="GtkAlignment" id="status_alignment">
+                <property name="visible">True</property>
+                <property name="left_padding">12</property>
+                <child>
+                  <widget class="GtkHBox" id="status_hbox">
+                    <property name="spacing">6</property>
+                    <child>
+                      <widget class="GtkImage" id="status_image">
+                        <property name="visible">True</property>
+                        <property name="no_show_all">True</property>
+                        <property name="xalign">0</property>
+                        <property name="stock">gtk-dialog-error</property>
+                      </widget>
+                      <packing>
+                        <property name="expand">False</property>
+                        <property name="fill">False</property>
+                      </packing>
+                    </child>
+                    <child>
+                      <widget class="GtkLabel" id="status_label">
+                        <property name="visible">True</property>
+                        <property name="xalign">0</property>
+                        <property name="label" translatable="yes">If you see this text something is wrong...</property>
+                        <property name="use_markup">True</property>
+                        <property name="use_underline">True</property>
+                      </widget>
+                      <packing>
+                        <property name="position">1</property>
+                      </packing>
+                    </child>
+                  </widget>
+                </child>
+              </widget>
+              <packing>
+                <property name="right_attach">3</property>
+                <property name="top_attach">2</property>
+                <property name="bottom_attach">3</property>
+              </packing>
+            </child>
+            <child>
+              <widget class="GtkLabel" id="label2">
+                <property name="visible">True</property>
+                <property name="xalign">0</property>
+                <property name="label" translatable="yes">&lt;b&gt;Build configuration&lt;/b&gt;</property>
+                <property name="use_markup">True</property>
+              </widget>
+              <packing>
+                <property name="right_attach">3</property>
+                <property name="top_attach">3</property>
+                <property name="bottom_attach">4</property>
+                <property name="y_options"></property>
+              </packing>
+            </child>
+            <child>
+              <widget class="GtkComboBox" id="image_combo">
+                <property name="visible">True</property>
+                <property name="sensitive">False</property>
+              </widget>
+              <packing>
+                <property name="left_attach">1</property>
+                <property name="right_attach">2</property>
+                <property name="top_attach">6</property>
+                <property name="bottom_attach">7</property>
+                <property name="y_options"></property>
+              </packing>
+            </child>
+            <child>
+              <widget class="GtkLabel" id="image_label">
+                <property name="visible">True</property>
+                <property name="sensitive">False</property>
+                <property name="xalign">0</property>
+                <property name="xpad">12</property>
+                <property name="label" translatable="yes">Image:</property>
+              </widget>
+              <packing>
+                <property name="top_attach">6</property>
+                <property name="bottom_attach">7</property>
+                <property name="y_options"></property>
+              </packing>
+            </child>
+            <child>
+              <widget class="GtkComboBox" id="distribution_combo">
+                <property name="visible">True</property>
+                <property name="sensitive">False</property>
+              </widget>
+              <packing>
+                <property name="left_attach">1</property>
+                <property name="right_attach">2</property>
+                <property name="top_attach">5</property>
+                <property name="bottom_attach">6</property>
+                <property name="y_options"></property>
+              </packing>
+            </child>
+            <child>
+              <widget class="GtkLabel" id="distribution_label">
+                <property name="visible">True</property>
+                <property name="sensitive">False</property>
+                <property name="xalign">0</property>
+                <property name="xpad">12</property>
+                <property name="label" translatable="yes">Distribution:</property>
+              </widget>
+              <packing>
+                <property name="top_attach">5</property>
+                <property name="bottom_attach">6</property>
+                <property name="y_options"></property>
+              </packing>
+            </child>
+            <child>
+              <widget class="GtkComboBox" id="machine_combo">
+                <property name="visible">True</property>
+                <property name="sensitive">False</property>
+              </widget>
+              <packing>
+                <property name="left_attach">1</property>
+                <property name="right_attach">2</property>
+                <property name="top_attach">4</property>
+                <property name="bottom_attach">5</property>
+                <property name="y_options"></property>
+              </packing>
+            </child>
+            <child>
+              <widget class="GtkLabel" id="machine_label">
+                <property name="visible">True</property>
+                <property name="sensitive">False</property>
+                <property name="xalign">0</property>
+                <property name="xpad">12</property>
+                <property name="label" translatable="yes">Machine:</property>
+              </widget>
+              <packing>
+                <property name="top_attach">4</property>
+                <property name="bottom_attach">5</property>
+                <property name="y_options"></property>
+              </packing>
+            </child>
+            <child>
+              <widget class="GtkButton" id="refresh_button">
+                <property name="visible">True</property>
+                <property name="sensitive">False</property>
+                <property name="can_focus">True</property>
+                <property name="receives_default">True</property>
+                <property name="label" translatable="yes">gtk-refresh</property>
+                <property name="use_stock">True</property>
+                <property name="response_id">0</property>
+              </widget>
+              <packing>
+                <property name="left_attach">2</property>
+                <property name="right_attach">3</property>
+                <property name="top_attach">1</property>
+                <property name="bottom_attach">2</property>
+                <property name="y_options"></property>
+              </packing>
+            </child>
+            <child>
+              <widget class="GtkEntry" id="location_entry">
+                <property name="visible">True</property>
+                <property name="can_focus">True</property>
+                <property name="width_chars">32</property>
+              </widget>
+              <packing>
+                <property name="left_attach">1</property>
+                <property name="right_attach">2</property>
+                <property name="top_attach">1</property>
+                <property name="bottom_attach">2</property>
+                <property name="y_options"></property>
+              </packing>
+            </child>
+            <child>
+              <widget class="GtkLabel" id="label3">
+                <property name="visible">True</property>
+                <property name="xalign">0</property>
+                <property name="xpad">12</property>
+                <property name="label" translatable="yes">Location:</property>
+              </widget>
+              <packing>
+                <property name="top_attach">1</property>
+                <property name="bottom_attach">2</property>
+                <property name="y_options"></property>
+              </packing>
+            </child>
+            <child>
+              <widget class="GtkLabel" id="label1">
+                <property name="visible">True</property>
+                <property name="xalign">0</property>
+                <property name="label" translatable="yes">&lt;b&gt;Repository&lt;/b&gt;</property>
+                <property name="use_markup">True</property>
+              </widget>
+              <packing>
+                <property name="right_attach">3</property>
+                <property name="y_options"></property>
+              </packing>
+            </child>
+            <child>
+              <widget class="GtkAlignment" id="alignment1">
+                <property name="visible">True</property>
+                <child>
+                  <placeholder/>
+                </child>
+              </widget>
+              <packing>
+                <property name="left_attach">2</property>
+                <property name="right_attach">3</property>
+                <property name="top_attach">4</property>
+                <property name="bottom_attach">5</property>
+                <property name="y_options"></property>
+              </packing>
+            </child>
+            <child>
+              <widget class="GtkAlignment" id="alignment2">
+                <property name="visible">True</property>
+                <child>
+                  <placeholder/>
+                </child>
+              </widget>
+              <packing>
+                <property name="left_attach">2</property>
+                <property name="right_attach">3</property>
+                <property name="top_attach">5</property>
+                <property name="bottom_attach">6</property>
+                <property name="y_options"></property>
+              </packing>
+            </child>
+            <child>
+              <widget class="GtkAlignment" id="alignment3">
+                <property name="visible">True</property>
+                <child>
+                  <placeholder/>
+                </child>
+              </widget>
+              <packing>
+                <property name="left_attach">2</property>
+                <property name="right_attach">3</property>
+                <property name="top_attach">6</property>
+                <property name="bottom_attach">7</property>
+                <property name="y_options"></property>
+              </packing>
+            </child>
+          </widget>
+          <packing>
+            <property name="position">1</property>
+          </packing>
+        </child>
+        <child internal-child="action_area">
+          <widget class="GtkHButtonBox" id="dialog-action_area1">
+            <property name="visible">True</property>
+            <property name="layout_style">GTK_BUTTONBOX_END</property>
+            <child>
+              <placeholder/>
+            </child>
+            <child>
+              <placeholder/>
+            </child>
+            <child>
+              <placeholder/>
+            </child>
+          </widget>
+          <packing>
+            <property name="expand">False</property>
+            <property name="pack_type">GTK_PACK_END</property>
+          </packing>
+        </child>
+      </widget>
+    </child>
+  </widget>
+  <widget class="GtkDialog" id="dialog2">
+    <property name="window_position">GTK_WIN_POS_CENTER_ON_PARENT</property>
+    <property name="type_hint">GDK_WINDOW_TYPE_HINT_DIALOG</property>
+    <property name="has_separator">False</property>
+    <child internal-child="vbox">
+      <widget class="GtkVBox" id="dialog-vbox2">
+        <property name="visible">True</property>
+        <property name="spacing">2</property>
+        <child>
+          <widget class="GtkTable" id="table2">
+            <property name="visible">True</property>
+            <property name="border_width">6</property>
+            <property name="n_rows">7</property>
+            <property name="n_columns">3</property>
+            <property name="column_spacing">6</property>
+            <property name="row_spacing">6</property>
+            <child>
+              <widget class="GtkLabel" id="label7">
+                <property name="visible">True</property>
+                <property name="xalign">0</property>
+                <property name="label" translatable="yes">&lt;b&gt;Repositories&lt;/b&gt;</property>
+                <property name="use_markup">True</property>
+              </widget>
+              <packing>
+                <property name="right_attach">3</property>
+                <property name="y_options"></property>
+              </packing>
+            </child>
+            <child>
+              <widget class="GtkAlignment" id="alignment4">
+                <property name="visible">True</property>
+                <property name="xalign">0</property>
+                <property name="left_padding">12</property>
+                <child>
+                  <widget class="GtkScrolledWindow" id="scrolledwindow1">
+                    <property name="visible">True</property>
+                    <property name="can_focus">True</property>
+                    <property name="hscrollbar_policy">GTK_POLICY_AUTOMATIC</property>
+                    <property name="vscrollbar_policy">GTK_POLICY_AUTOMATIC</property>
+                    <child>
+                      <widget class="GtkTreeView" id="treeview1">
+                        <property name="visible">True</property>
+                        <property name="can_focus">True</property>
+                        <property name="headers_clickable">True</property>
+                      </widget>
+                    </child>
+                  </widget>
+                </child>
+              </widget>
+              <packing>
+                <property name="right_attach">3</property>
+                <property name="top_attach">2</property>
+                <property name="bottom_attach">3</property>
+                <property name="y_options"></property>
+              </packing>
+            </child>
+            <child>
+              <widget class="GtkEntry" id="entry1">
+                <property name="visible">True</property>
+                <property name="can_focus">True</property>
+              </widget>
+              <packing>
+                <property name="left_attach">1</property>
+                <property name="right_attach">3</property>
+                <property name="top_attach">1</property>
+                <property name="bottom_attach">2</property>
+                <property name="y_options"></property>
+              </packing>
+            </child>
+            <child>
+              <widget class="GtkLabel" id="label9">
+                <property name="visible">True</property>
+                <property name="xalign">0</property>
+                <property name="label" translatable="yes">&lt;b&gt;Additional packages&lt;/b&gt;</property>
+                <property name="use_markup">True</property>
+              </widget>
+              <packing>
+                <property name="right_attach">3</property>
+                <property name="top_attach">4</property>
+                <property name="bottom_attach">5</property>
+                <property name="y_options"></property>
+              </packing>
+            </child>
+            <child>
+              <widget class="GtkAlignment" id="alignment6">
+                <property name="visible">True</property>
+                <property name="xalign">0</property>
+                <property name="xscale">0</property>
+                <child>
+                  <widget class="GtkLabel" id="label8">
+                    <property name="visible">True</property>
+                    <property name="xalign">0</property>
+                    <property name="yalign">0</property>
+                    <property name="xpad">12</property>
+                    <property name="label" translatable="yes">Location: </property>
+                  </widget>
+                </child>
+              </widget>
+              <packing>
+                <property name="top_attach">1</property>
+                <property name="bottom_attach">2</property>
+                <property name="y_options"></property>
+              </packing>
+            </child>
+            <child>
+              <widget class="GtkAlignment" id="alignment7">
+                <property name="visible">True</property>
+                <property name="xalign">1</property>
+                <property name="xscale">0</property>
+                <child>
+                  <widget class="GtkHButtonBox" id="hbuttonbox1">
+                    <property name="visible">True</property>
+                    <property name="spacing">5</property>
+                    <child>
+                      <widget class="GtkButton" id="button7">
+                        <property name="visible">True</property>
+                        <property name="can_focus">True</property>
+                        <property name="receives_default">True</property>
+                        <property name="label" translatable="yes">gtk-remove</property>
+                        <property name="use_stock">True</property>
+                        <property name="response_id">0</property>
+                      </widget>
+                    </child>
+                    <child>
+                      <widget class="GtkButton" id="button6">
+                        <property name="visible">True</property>
+                        <property name="can_focus">True</property>
+                        <property name="receives_default">True</property>
+                        <property name="label" translatable="yes">gtk-edit</property>
+                        <property name="use_stock">True</property>
+                        <property name="response_id">0</property>
+                      </widget>
+                      <packing>
+                        <property name="position">1</property>
+                      </packing>
+                    </child>
+                    <child>
+                      <widget class="GtkButton" id="button5">
+                        <property name="visible">True</property>
+                        <property name="can_focus">True</property>
+                        <property name="receives_default">True</property>
+                        <property name="label" translatable="yes">gtk-add</property>
+                        <property name="use_stock">True</property>
+                        <property name="response_id">0</property>
+                      </widget>
+                      <packing>
+                        <property name="position">2</property>
+                      </packing>
+                    </child>
+                  </widget>
+                </child>
+              </widget>
+              <packing>
+                <property name="left_attach">1</property>
+                <property name="right_attach">3</property>
+                <property name="top_attach">3</property>
+                <property name="bottom_attach">4</property>
+                <property name="y_options"></property>
+              </packing>
+            </child>
+            <child>
+              <widget class="GtkAlignment" id="alignment5">
+                <property name="visible">True</property>
+                <child>
+                  <placeholder/>
+                </child>
+              </widget>
+              <packing>
+                <property name="top_attach">3</property>
+                <property name="bottom_attach">4</property>
+                <property name="y_options"></property>
+              </packing>
+            </child>
+            <child>
+              <widget class="GtkLabel" id="label10">
+                <property name="visible">True</property>
+                <property name="xalign">0</property>
+                <property name="yalign">0</property>
+                <property name="xpad">12</property>
+                <property name="label" translatable="yes">Search:</property>
+              </widget>
+              <packing>
+                <property name="top_attach">5</property>
+                <property name="bottom_attach">6</property>
+                <property name="y_options"></property>
+              </packing>
+            </child>
+            <child>
+              <widget class="GtkEntry" id="entry2">
+                <property name="visible">True</property>
+                <property name="can_focus">True</property>
+              </widget>
+              <packing>
+                <property name="left_attach">1</property>
+                <property name="right_attach">3</property>
+                <property name="top_attach">5</property>
+                <property name="bottom_attach">6</property>
+                <property name="y_options"></property>
+              </packing>
+            </child>
+            <child>
+              <widget class="GtkAlignment" id="alignment8">
+                <property name="visible">True</property>
+                <property name="xalign">0</property>
+                <property name="left_padding">12</property>
+                <child>
+                  <widget class="GtkScrolledWindow" id="scrolledwindow2">
+                    <property name="visible">True</property>
+                    <property name="can_focus">True</property>
+                    <property name="hscrollbar_policy">GTK_POLICY_AUTOMATIC</property>
+                    <property name="vscrollbar_policy">GTK_POLICY_AUTOMATIC</property>
+                    <child>
+                      <widget class="GtkTreeView" id="treeview2">
+                        <property name="visible">True</property>
+                        <property name="can_focus">True</property>
+                        <property name="headers_clickable">True</property>
+                      </widget>
+                    </child>
+                  </widget>
+                </child>
+              </widget>
+              <packing>
+                <property name="right_attach">3</property>
+                <property name="top_attach">6</property>
+                <property name="bottom_attach">7</property>
+                <property name="y_options"></property>
+              </packing>
+            </child>
+          </widget>
+          <packing>
+            <property name="position">1</property>
+          </packing>
+        </child>
+        <child internal-child="action_area">
+          <widget class="GtkHButtonBox" id="dialog-action_area2">
+            <property name="visible">True</property>
+            <property name="layout_style">GTK_BUTTONBOX_END</property>
+            <child>
+              <widget class="GtkButton" id="button4">
+                <property name="visible">True</property>
+                <property name="can_focus">True</property>
+                <property name="receives_default">True</property>
+                <property name="label" translatable="yes">gtk-close</property>
+                <property name="use_stock">True</property>
+                <property name="response_id">0</property>
+              </widget>
+            </child>
+          </widget>
+          <packing>
+            <property name="expand">False</property>
+            <property name="pack_type">GTK_PACK_END</property>
+          </packing>
+        </child>
+      </widget>
+    </child>
+  </widget>
+  <widget class="GtkWindow" id="main_window">
+    <child>
+      <widget class="GtkVBox" id="main_window_vbox">
+        <property name="visible">True</property>
+        <child>
+          <widget class="GtkToolbar" id="main_toolbar">
+            <property name="visible">True</property>
+            <child>
+              <widget class="GtkToolButton" id="main_toolbutton_build">
+                <property name="visible">True</property>
+                <property name="label" translatable="yes">Build</property>
+                <property name="stock_id">gtk-execute</property>
+              </widget>
+              <packing>
+                <property name="expand">False</property>
+              </packing>
+            </child>
+          </widget>
+          <packing>
+            <property name="expand">False</property>
+          </packing>
+        </child>
+        <child>
+          <widget class="GtkVPaned" id="vpaned1">
+            <property name="visible">True</property>
+            <property name="can_focus">True</property>
+            <child>
+              <widget class="GtkScrolledWindow" id="results_scrolledwindow">
+                <property name="visible">True</property>
+                <property name="can_focus">True</property>
+                <property name="hscrollbar_policy">GTK_POLICY_AUTOMATIC</property>
+                <property name="vscrollbar_policy">GTK_POLICY_AUTOMATIC</property>
+                <child>
+                  <placeholder/>
+                </child>
+              </widget>
+              <packing>
+                <property name="resize">False</property>
+                <property name="shrink">True</property>
+              </packing>
+            </child>
+            <child>
+              <widget class="GtkScrolledWindow" id="progress_scrolledwindow">
+                <property name="visible">True</property>
+                <property name="can_focus">True</property>
+                <property name="hscrollbar_policy">GTK_POLICY_AUTOMATIC</property>
+                <property name="vscrollbar_policy">GTK_POLICY_AUTOMATIC</property>
+                <child>
+                  <placeholder/>
+                </child>
+              </widget>
+              <packing>
+                <property name="resize">True</property>
+                <property name="shrink">True</property>
+              </packing>
+            </child>
+          </widget>
+          <packing>
+            <property name="position">1</property>
+          </packing>
+        </child>
+      </widget>
+    </child>
+  </widget>
+</glade-interface>
--- a/bitbake/lib/bb/ui/crumbs/runningbuild.py
+++ b/bitbake/lib/bb/ui/crumbs/runningbuild.py
@@ -0,0 +1,178 @@
+#
+# BitBake Graphical GTK User Interface
+#
+# Copyright (C) 2008        Intel Corporation
+#
+# Authored by Rob Bradford <rob@linux.intel.com>
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License version 2 as
+# published by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License along
+# with this program; if not, write to the Free Software Foundation, Inc.,
+# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+
+import gtk
+import gobject
+
+class RunningBuildModel (gtk.TreeStore):
+    (COL_TYPE, COL_PACKAGE, COL_TASK, COL_MESSAGE, COL_ICON, COL_ACTIVE) = (0, 1, 2, 3, 4, 5)
+    def __init__ (self):
+        gtk.TreeStore.__init__ (self,
+                                gobject.TYPE_STRING,
+                                gobject.TYPE_STRING,
+                                gobject.TYPE_STRING,
+                                gobject.TYPE_STRING,
+                                gobject.TYPE_STRING,
+                                gobject.TYPE_BOOLEAN)
+
+class RunningBuild (gobject.GObject):
+    __gsignals__ = {
+          'build-succeeded' : (gobject.SIGNAL_RUN_LAST,
+                               gobject.TYPE_NONE,
+                               ()),
+          'build-failed' : (gobject.SIGNAL_RUN_LAST,
+                            gobject.TYPE_NONE,
+                            ())
+          }
+    pids_to_task = {}
+    tasks_to_iter = {}
+
+    def __init__ (self):
+        gobject.GObject.__init__ (self)
+        self.model = RunningBuildModel()
+
+    def handle_event (self, event):
+        # Handle an event from the event queue, this may result in updating
+        # the model and thus the UI. Or it may be to tell us that the build
+        # has finished successfully (or not, as the case may be.)
+
+        parent = None
+        pid = 0
+        package = None
+        task = None
+
+        # If we have a pid attached to this message/event try and get the
+        # (package, task) pair for it. If we get that then get the parent iter
+        # for the message.
+        if hasattr(event, 'pid'):
+            pid = event.pid
+            if pid in self.pids_to_task:
+                (package, task) = self.pids_to_task[pid]
+                parent = self.tasks_to_iter[(package, task)]
+
+        if isinstance(event, bb.msg.Msg):
+            # Set a pretty icon for the message based on it's type.
+            if isinstance(event, bb.msg.MsgWarn):
+                icon = "dialog-warning"
+            elif isinstance(event, bb.msg.MsgErr):
+                icon = "dialog-error"
+            else:
+                icon = None
+
+            # Ignore the "Running task i of n .." messages
+            if (event._message.startswith ("Running task")):
+                return
+
+            # Add the message to the tree either at the top level if parent is
+            # None otherwise as a descendent of a task.
+            self.model.append (parent,
+                               (event.__name__.split()[-1], # e.g. MsgWarn, MsgError
+                                package,
+                                task,
+                                event._message,
+                                icon,
+                                False))
+        elif isinstance(event, bb.build.TaskStarted):
+            (package, task) = (event._package, event._task)
+
+            # Save out this PID.
+            self.pids_to_task[pid] = (package, task)
+
+            # Check if we already have this package in our model. If so then
+            # that can be the parent for the task. Otherwise we create a new
+            # top level for the package.
+            if ((package, None) in self.tasks_to_iter):
+                parent = self.tasks_to_iter[(package, None)]
+            else:
+                parent = self.model.append (None, (None,
+                                                   package,
+                                                   None,
+                                                   "Package: %s" % (package),
+                                                   None,
+                                                   False))
+                self.tasks_to_iter[(package, None)] = parent
+
+            # Because this parent package now has an active child mark it as
+            # such.
+            self.model.set(parent, self.model.COL_ICON, "gtk-execute")
+
+            # Add an entry in the model for this task
+            i = self.model.append (parent, (None,
+                                            package,
+                                            task,
+                                            "Task: %s" % (task),
+                                            None,
+                                            False))
+
+            # Save out the iter so that we can find it when we have a message
+            # that we need to attach to a task.
+            self.tasks_to_iter[(package, task)] = i
+
+            # Mark this task as active.
+            self.model.set(i, self.model.COL_ICON, "gtk-execute")
+
+        elif isinstance(event, bb.build.Task):
+
+            if isinstance(event, bb.build.TaskFailed):
+                # Mark the task as failed
+                i = self.tasks_to_iter[(package, task)]
+                self.model.set(i, self.model.COL_ICON, "dialog-error")
+
+                # Mark the parent package as failed
+                i = self.tasks_to_iter[(package, None)]
+                self.model.set(i, self.model.COL_ICON, "dialog-error")
+            else:
+                # Mark the task as inactive
+                i = self.tasks_to_iter[(package, task)]
+                self.model.set(i, self.model.COL_ICON, None)
+
+                # Mark the parent package as inactive
+                i = self.tasks_to_iter[(package, None)]
+                self.model.set(i, self.model.COL_ICON, None)
+
+
+            # Clear the iters and the pids since when the task goes away the
+            # pid will no longer be used for messages
+            del self.tasks_to_iter[(package, task)]
+            del self.pids_to_task[pid]
+
+        elif isinstance(event, bb.event.BuildCompleted):
+            failures = int (event._failures)
+
+            # Emit the appropriate signal depending on the number of failures
+            if (failures > 1):
+                self.emit ("build-failed")
+            else:
+                self.emit ("build-succeeded")
+
+class RunningBuildTreeView (gtk.TreeView):
+    def __init__ (self):
+        gtk.TreeView.__init__ (self)
+
+        # The icon that indicates whether we're building or failed.
+        renderer = gtk.CellRendererPixbuf ()
+        col = gtk.TreeViewColumn ("Status", renderer)
+        col.add_attribute (renderer, "icon-name", 4)
+        self.append_column (col)
+
+        # The message of the build.
+        renderer = gtk.CellRendererText ()
+        col = gtk.TreeViewColumn ("Message", renderer, text=3)
+        self.append_column (col)
--- a/bitbake/lib/bb/ui/depexp.py
+++ b/bitbake/lib/bb/ui/depexp.py
@@ -0,0 +1,271 @@
+#
+# BitBake Graphical GTK based Dependency Explorer
+#
+# Copyright (C) 2007        Ross Burton
+# Copyright (C) 2007 - 2008 Richard Purdie
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License version 2 as
+# published by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License along
+# with this program; if not, write to the Free Software Foundation, Inc.,
+# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+
+import gobject
+import gtk
+import threading
+import xmlrpclib
+
+# Package Model
+(COL_PKG_NAME) = (0)
+
+# Dependency Model
+(TYPE_DEP, TYPE_RDEP) = (0, 1)
+(COL_DEP_TYPE, COL_DEP_PARENT, COL_DEP_PACKAGE) = (0, 1, 2)
+
+class PackageDepView(gtk.TreeView):
+    def __init__(self, model, dep_type, label):
+        gtk.TreeView.__init__(self)
+        self.current = None
+        self.dep_type = dep_type
+        self.filter_model = model.filter_new()
+        self.filter_model.set_visible_func(self._filter)
+        self.set_model(self.filter_model)
+        #self.connect("row-activated", self.on_package_activated, COL_DEP_PACKAGE)
+        self.append_column(gtk.TreeViewColumn(label, gtk.CellRendererText(), text=COL_DEP_PACKAGE))
+
+    def _filter(self, model, iter):
+        (this_type, package) = model.get(iter, COL_DEP_TYPE, COL_DEP_PARENT)
+        if this_type != self.dep_type: return False
+        return package == self.current
+
+    def set_current_package(self, package):
+        self.current = package
+        self.filter_model.refilter()
+
+class PackageReverseDepView(gtk.TreeView):
+    def __init__(self, model, label):
+        gtk.TreeView.__init__(self)
+        self.current = None
+        self.filter_model = model.filter_new()
+        self.filter_model.set_visible_func(self._filter)
+        self.set_model(self.filter_model)
+        self.append_column(gtk.TreeViewColumn(label, gtk.CellRendererText(), text=COL_DEP_PARENT))
+
+    def _filter(self, model, iter):
+        package = model.get_value(iter, COL_DEP_PACKAGE)
+        return package == self.current
+
+    def set_current_package(self, package):
+        self.current = package
+        self.filter_model.refilter()
+
+class DepExplorer(gtk.Window):
+    def __init__(self):
+        gtk.Window.__init__(self)
+        self.set_title("Dependency Explorer")
+        self.set_default_size(500, 500)
+        self.connect("delete-event", gtk.main_quit)
+
+        # Create the data models
+        self.pkg_model = gtk.ListStore(gobject.TYPE_STRING)
+        self.depends_model = gtk.ListStore(gobject.TYPE_INT, gobject.TYPE_STRING, gobject.TYPE_STRING)
+
+        pane = gtk.HPaned()
+        pane.set_position(250)
+        self.add(pane)
+
+        # The master list of packages
+        scrolled = gtk.ScrolledWindow()
+        scrolled.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
+        scrolled.set_shadow_type(gtk.SHADOW_IN)
+        self.pkg_treeview = gtk.TreeView(self.pkg_model)
+        self.pkg_treeview.get_selection().connect("changed", self.on_cursor_changed)
+        self.pkg_treeview.append_column(gtk.TreeViewColumn("Package", gtk.CellRendererText(), text=COL_PKG_NAME))
+        pane.add1(scrolled)
+        scrolled.add(self.pkg_treeview)
+
+        box = gtk.VBox(homogeneous=True, spacing=4)
+
+        # Runtime Depends
+        scrolled = gtk.ScrolledWindow()
+        scrolled.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
+        scrolled.set_shadow_type(gtk.SHADOW_IN)
+        self.rdep_treeview = PackageDepView(self.depends_model, TYPE_RDEP, "Runtime Depends")
+        self.rdep_treeview.connect("row-activated", self.on_package_activated, COL_DEP_PACKAGE)
+        scrolled.add(self.rdep_treeview)
+        box.add(scrolled)
+
+        # Build Depends
+        scrolled = gtk.ScrolledWindow()
+        scrolled.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
+        scrolled.set_shadow_type(gtk.SHADOW_IN)
+        self.dep_treeview = PackageDepView(self.depends_model, TYPE_DEP, "Build Depends")
+        self.dep_treeview.connect("row-activated", self.on_package_activated, COL_DEP_PACKAGE)
+        scrolled.add(self.dep_treeview)
+        box.add(scrolled)
+        pane.add2(box)
+
+        # Reverse Depends
+        scrolled = gtk.ScrolledWindow()
+        scrolled.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
+        scrolled.set_shadow_type(gtk.SHADOW_IN)
+        self.revdep_treeview = PackageReverseDepView(self.depends_model, "Reverse Depends")
+        self.revdep_treeview.connect("row-activated", self.on_package_activated, COL_DEP_PARENT)
+        scrolled.add(self.revdep_treeview)
+        box.add(scrolled)
+        pane.add2(box)
+
+        self.show_all()
+
+    def on_package_activated(self, treeview, path, column, data_col):
+        model = treeview.get_model()
+        package = model.get_value(model.get_iter(path), data_col)
+
+        pkg_path = []
+        def finder(model, path, iter, needle):
+            package = model.get_value(iter, COL_PKG_NAME)
+            if package == needle:
+                pkg_path.append(path)
+                return True
+            else:
+                return False
+        self.pkg_model.foreach(finder, package)
+        if pkg_path:
+            self.pkg_treeview.get_selection().select_path(pkg_path[0])
+            self.pkg_treeview.scroll_to_cell(pkg_path[0])
+
+    def on_cursor_changed(self, selection):
+        (model, it) = selection.get_selected()
+        if iter is None:
+            current_package = None
+        else:
+            current_package = model.get_value(it, COL_PKG_NAME)
+        self.rdep_treeview.set_current_package(current_package)
+        self.dep_treeview.set_current_package(current_package)
+        self.revdep_treeview.set_current_package(current_package)
+
+
+def parse(depgraph, pkg_model, depends_model):
+
+    for package in depgraph["pn"]:
+        pkg_model.set(pkg_model.append(), COL_PKG_NAME, package)
+
+    for package in depgraph["depends"]:
+        for depend in depgraph["depends"][package]:
+            depends_model.set (depends_model.append(),
+                              COL_DEP_TYPE, TYPE_DEP,
+                              COL_DEP_PARENT, package,
+                              COL_DEP_PACKAGE, depend)
+
+    for package in depgraph["rdepends-pn"]:
+        for rdepend in depgraph["rdepends-pn"][package]:
+            depends_model.set (depends_model.append(),
+                              COL_DEP_TYPE, TYPE_RDEP,
+                              COL_DEP_PARENT, package,
+                              COL_DEP_PACKAGE, rdepend)
+
+class ProgressBar(gtk.Window):
+    def __init__(self):
+
+        gtk.Window.__init__(self)
+        self.set_title("Parsing .bb files, please wait...")
+        self.set_default_size(500, 0)
+        self.connect("delete-event", gtk.main_quit)
+
+        self.progress = gtk.ProgressBar()
+        self.add(self.progress)
+        self.show_all()
+
+class gtkthread(threading.Thread):
+    quit = threading.Event()
+    def __init__(self, shutdown):
+        threading.Thread.__init__(self)
+        self.setDaemon(True)
+        self.shutdown = shutdown
+
+    def run(self):
+        gobject.threads_init()
+        gtk.gdk.threads_init()
+        gtk.main()
+        gtkthread.quit.set()
+
+def init(server, eventHandler):
+
+    try:
+        cmdline = server.runCommand(["getCmdLineAction"])
+        if not cmdline or cmdline[0] != "generateDotGraph":
+            print("This UI is only compatible with the -g option")
+            return
+        ret = server.runCommand(["generateDepTreeEvent", cmdline[1], cmdline[2]])
+        if ret != True:
+            print("Couldn't run command! %s" % ret)
+            return
+    except xmlrpclib.Fault as x:
+        print("XMLRPC Fault getting commandline:\n %s" % x)
+        return
+
+    shutdown = 0
+
+    gtkgui = gtkthread(shutdown)
+    gtkgui.start()
+
+    gtk.gdk.threads_enter()
+    pbar = ProgressBar()
+    dep = DepExplorer()
+    gtk.gdk.threads_leave()
+
+    while True:
+        try:
+            event = eventHandler.waitEvent(0.25)
+            if gtkthread.quit.isSet():
+                break
+
+            if event is None:
+                continue
+            if isinstance(event, bb.event.ParseProgress):
+                x = event.sofar
+                y = event.total
+                if x == y:
+                    print(("\nParsing finished. %d cached, %d parsed, %d skipped, %d masked, %d errors."
+                        % ( event.cached, event.parsed, event.skipped, event.masked, event.errors)))
+                    pbar.hide()
+                gtk.gdk.threads_enter()
+                pbar.progress.set_fraction(float(x)/float(y))
+                pbar.progress.set_text("%d/%d (%2d %%)" % (x, y, x*100/y))
+                gtk.gdk.threads_leave()
+                continue
+
+            if isinstance(event, bb.event.DepTreeGenerated):
+                gtk.gdk.threads_enter()
+                parse(event._depgraph, dep.pkg_model, dep.depends_model)
+                gtk.gdk.threads_leave()
+
+            if isinstance(event, bb.command.CookerCommandCompleted):
+                continue
+            if isinstance(event, bb.command.CookerCommandFailed):
+                print("Command execution failed: %s" % event.error)
+                break
+            if isinstance(event, bb.cooker.CookerExit):
+                break
+
+            continue
+
+        except KeyboardInterrupt:
+            if shutdown == 2:
+                print("\nThird Keyboard Interrupt, exit.\n")
+                break
+            if shutdown == 1:
+                print("\nSecond Keyboard Interrupt, stopping...\n")
+                server.runCommand(["stateStop"])
+            if shutdown == 0:
+                print("\nKeyboard Interrupt, closing down...\n")
+                server.runCommand(["stateShutdown"])
+            shutdown = shutdown + 1
+            pass
--- a/bitbake/lib/bb/ui/goggle.py
+++ b/bitbake/lib/bb/ui/goggle.py
@@ -0,0 +1,76 @@
+#
+# BitBake Graphical GTK User Interface
+#
+# Copyright (C) 2008        Intel Corporation
+#
+# Authored by Rob Bradford <rob@linux.intel.com>
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License version 2 as
+# published by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License along
+# with this program; if not, write to the Free Software Foundation, Inc.,
+# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+
+import gobject
+import gtk
+import xmlrpclib
+from bb.ui.crumbs.runningbuild import RunningBuildTreeView, RunningBuild
+
+def event_handle_idle_func (eventHandler, build):
+
+    # Consume as many messages as we can in the time available to us
+    event = eventHandler.getEvent()
+    while event:
+        build.handle_event (event)
+        event = eventHandler.getEvent()
+
+    return True
+
+class MainWindow (gtk.Window):
+    def __init__ (self):
+        gtk.Window.__init__ (self, gtk.WINDOW_TOPLEVEL)
+
+        # Setup tree view and the scrolled window
+        scrolled_window = gtk.ScrolledWindow ()
+        self.add (scrolled_window)
+        self.cur_build_tv = RunningBuildTreeView()
+        scrolled_window.add (self.cur_build_tv)
+
+def init (server, eventHandler):
+    gobject.threads_init()
+    gtk.gdk.threads_init()
+
+    window = MainWindow ()
+    window.show_all ()
+
+    # Create the object for the current build
+    running_build = RunningBuild ()
+    window.cur_build_tv.set_model (running_build.model)
+    try:
+        cmdline = server.runCommand(["getCmdLineAction"])
+        print(cmdline)
+        if not cmdline:
+            return 1
+        ret = server.runCommand(cmdline)
+        if ret != True:
+            print("Couldn't get default commandline! %s" % ret)
+            return 1
+    except xmlrpclib.Fault as x:
+        print("XMLRPC Fault getting commandline:\n %s" % x)
+        return 1
+
+    # Use a timeout function for probing the event queue to find out if we
+    # have a message waiting for us.
+    gobject.timeout_add (200,
+                         event_handle_idle_func,
+                         eventHandler,
+                         running_build)
+
+    gtk.main()
--- a/bitbake/lib/bb/ui/knotty.py
+++ b/bitbake/lib/bb/ui/knotty.py
@@ -0,0 +1,192 @@
+#
+# BitBake (No)TTY UI Implementation
+#
+# Handling output to TTYs or files (no TTY)
+#
+# Copyright (C) 2006-2007 Richard Purdie
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License version 2 as
+# published by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License along
+# with this program; if not, write to the Free Software Foundation, Inc.,
+# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+
+from __future__ import division
+
+import os
+import sys
+import itertools
+import xmlrpclib
+from bb import ui
+from bb.ui import uihelper
+
+
+parsespin = itertools.cycle( r'|/-\\' )
+
+def init(server, eventHandler):
+
+    # Get values of variables which control our output
+    includelogs = server.runCommand(["getVariable", "BBINCLUDELOGS"])
+    loglines = server.runCommand(["getVariable", "BBINCLUDELOGS_LINES"])
+
+    helper = uihelper.BBUIHelper()
+
+    try:
+        cmdline = server.runCommand(["getCmdLineAction"])
+        #print cmdline
+        if not cmdline:
+            return 1
+        ret = server.runCommand(cmdline)
+        if ret != True:
+            print("Couldn't get default commandline! %s" % ret)
+            return 1
+    except xmlrpclib.Fault as x:
+        print("XMLRPC Fault getting commandline:\n %s" % x)
+        return 1
+
+    shutdown = 0
+    return_value = 0
+    while True:
+        try:
+            event = eventHandler.waitEvent(0.25)
+            if event is None:
+                continue
+            #print event
+            helper.eventHandler(event)
+            if isinstance(event, bb.runqueue.runQueueExitWait):
+                if not shutdown:
+                    shutdown = 1
+            if shutdown and helper.needUpdate:
+                activetasks, failedtasks = helper.getTasks()
+                if activetasks:
+                    print("Waiting for %s active tasks to finish:" % len(activetasks))
+                    tasknum = 1
+                    for task in activetasks:
+                        print("%s: %s (pid %s)" % (tasknum, activetasks[task]["title"], task))
+                        tasknum = tasknum + 1
+
+            if isinstance(event, bb.msg.MsgPlain):
+                print(event._message)
+                continue
+            if isinstance(event, bb.msg.MsgDebug):
+                print('DEBUG: ' + event._message)
+                continue
+            if isinstance(event, bb.msg.MsgNote):
+                print('NOTE: ' + event._message)
+                continue
+            if isinstance(event, bb.msg.MsgWarn):
+                print('WARNING: ' + event._message)
+                continue
+            if isinstance(event, bb.msg.MsgError):
+                return_value = 1
+                print('ERROR: ' + event._message)
+                continue
+            if isinstance(event, bb.msg.MsgFatal):
+                return_value = 1
+                print('FATAL: ' + event._message)
+                continue
+            if isinstance(event, bb.build.TaskFailed):
+                return_value = 1
+                logfile = event.logfile
+                if logfile and os.path.exists(logfile):
+                    print("ERROR: Logfile of failure stored in: %s" % logfile)
+                    if 1 or includelogs:
+                        print("Log data follows:")
+                        f = open(logfile, "r")
+                        lines = []
+                        while True:
+                            l = f.readline()
+                            if l == '':
+                                break
+                            l = l.rstrip()
+                            if loglines:
+                                lines.append(' | %s' % l)
+                                if len(lines) > int(loglines):
+                                    lines.pop(0)
+                            else:
+                                print('| %s' % l)
+                        f.close()
+                        if lines:
+                            for line in lines:
+                                print(line)
+            if isinstance(event, bb.build.TaskBase):
+                print("NOTE: %s" % event._message)
+                continue
+            if isinstance(event, bb.event.ParseProgress):
+                x = event.sofar
+                y = event.total
+                if os.isatty(sys.stdout.fileno()):
+                    sys.stdout.write("\rNOTE: Handling BitBake files: %s (%04d/%04d) [%2d %%]" % ( next(parsespin), x, y, x*100//y ) )
+                    sys.stdout.flush()
+                else:
+                    if x == 1:
+                        sys.stdout.write("Parsing .bb files, please wait...")
+                        sys.stdout.flush()
+                    if x == y:
+                        sys.stdout.write("done.")
+                        sys.stdout.flush()
+                if x == y:
+                    print(("\nParsing of %d .bb files complete (%d cached, %d parsed). %d targets, %d skipped, %d masked, %d errors."
+                        % ( event.total, event.cached, event.parsed, event.virtuals, event.skipped, event.masked, event.errors)))
+                continue
+
+            if isinstance(event, bb.command.CookerCommandCompleted):
+                break
+            if isinstance(event, bb.command.CookerCommandSetExitCode):
+                return_value = event.exitcode
+                continue
+            if isinstance(event, bb.command.CookerCommandFailed):
+                return_value = 1
+                print("Command execution failed: %s" % event.error)
+                break
+            if isinstance(event, bb.cooker.CookerExit):
+                break
+            if isinstance(event, bb.event.MultipleProviders):
+                print("NOTE: multiple providers are available for %s%s (%s)" % (event._is_runtime and "runtime " or "",
+                                                                                event._item,
+                                                                                ", ".join(event._candidates)))
+                print("NOTE: consider defining a PREFERRED_PROVIDER entry to match %s" % event._item)
+                continue
+            if isinstance(event, bb.event.NoProvider):
+                if event._runtime:
+                    r = "R"
+                else:
+                    r = ""
+
+                if event._dependees:
+                    print("ERROR: Nothing %sPROVIDES '%s' (but %s %sDEPENDS on or otherwise requires it)" % (r, event._item, ", ".join(event._dependees), r))
+                else:
+                    print("ERROR: Nothing %sPROVIDES '%s'" % (r, event._item))
+                continue
+
+            # ignore
+            if isinstance(event, (bb.event.BuildBase,
+                                  bb.event.StampUpdate,
+                                  bb.event.ConfigParsed,
+                                  bb.event.RecipeParsed,
+                                  bb.runqueue.runQueueEvent,
+                                  bb.runqueue.runQueueExitWait)):
+                continue
+
+            print("Unknown Event: %s" % event)
+
+        except KeyboardInterrupt:
+            if shutdown == 2:
+                print("\nThird Keyboard Interrupt, exit.\n")
+                break
+            if shutdown == 1:
+                print("\nSecond Keyboard Interrupt, stopping...\n")
+                server.runCommand(["stateStop"])
+            if shutdown == 0:
+                print("\nKeyboard Interrupt, closing down...\n")
+                server.runCommand(["stateShutdown"])
+            shutdown = shutdown + 1
+            pass
+    return return_value
--- a/bitbake/lib/bb/ui/ncurses.py
+++ b/bitbake/lib/bb/ui/ncurses.py
@@ -0,0 +1,336 @@
+#
+# BitBake Curses UI Implementation
+#
+# Implements an ncurses frontend for the BitBake utility.
+#
+# Copyright (C) 2006 Michael 'Mickey' Lauer
+# Copyright (C) 2006-2007 Richard Purdie
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License version 2 as
+# published by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License along
+# with this program; if not, write to the Free Software Foundation, Inc.,
+# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+
+"""
+    We have the following windows:
+
+        1.) Main Window: Shows what we are ultimately building and how far we are. Includes status bar
+        2.) Thread Activity Window: Shows one status line for every concurrent bitbake thread.
+        3.) Command Line Window: Contains an interactive command line where you can interact w/ Bitbake.
+
+    Basic window layout is like that:
+
+        |---------------------------------------------------------|
+        | <Main Window>               | <Thread Activity Window>  |
+        |                             | 0: foo do_compile complete|
+        | Building Gtk+-2.6.10        | 1: bar do_patch complete  |
+        | Status: 60%                 | ...                       |
+        |                             | ...                       |
+        |                             | ...                       |
+        |---------------------------------------------------------|
+        |<Command Line Window>                                    |
+        |>>> which virtual/kernel                                 |
+        |openzaurus-kernel                                        |
+        |>>> _                                                    |
+        |---------------------------------------------------------|
+
+"""
+
+from __future__ import division
+
+import os, sys, curses, itertools, time
+import bb
+import xmlrpclib
+from bb import ui
+from bb.ui import uihelper
+
+parsespin = itertools.cycle( r'|/-\\' )
+
+X = 0
+Y = 1
+WIDTH = 2
+HEIGHT = 3
+
+MAXSTATUSLENGTH = 32
+
+class NCursesUI:
+    """
+    NCurses UI Class
+    """
+    class Window:
+        """Base Window Class"""
+        def __init__( self, x, y, width, height, fg=curses.COLOR_BLACK, bg=curses.COLOR_WHITE ):
+            self.win = curses.newwin( height, width, y, x )
+            self.dimensions = ( x, y, width, height )
+            """
+            if curses.has_colors():
+                color = 1
+                curses.init_pair( color, fg, bg )
+                self.win.bkgdset( ord(' '), curses.color_pair(color) )
+            else:
+                self.win.bkgdset( ord(' '), curses.A_BOLD )
+            """
+            self.erase()
+            self.setScrolling()
+            self.win.noutrefresh()
+
+        def erase( self ):
+            self.win.erase()
+
+        def setScrolling( self, b = True ):
+            self.win.scrollok( b )
+            self.win.idlok( b )
+
+        def setBoxed( self ):
+            self.boxed = True
+            self.win.box()
+            self.win.noutrefresh()
+
+        def setText( self, x, y, text, *args ):
+            self.win.addstr( y, x, text, *args )
+            self.win.noutrefresh()
+
+        def appendText( self, text, *args ):
+            self.win.addstr( text, *args )
+            self.win.noutrefresh()
+
+        def drawHline( self, y ):
+            self.win.hline( y, 0, curses.ACS_HLINE, self.dimensions[WIDTH] )
+            self.win.noutrefresh()
+
+    class DecoratedWindow( Window ):
+        """Base class for windows with a box and a title bar"""
+        def __init__( self, title, x, y, width, height, fg=curses.COLOR_BLACK, bg=curses.COLOR_WHITE ):
+            NCursesUI.Window.__init__( self, x+1, y+3, width-2, height-4, fg, bg )
+            self.decoration = NCursesUI.Window( x, y, width, height, fg, bg )
+            self.decoration.setBoxed()
+            self.decoration.win.hline( 2, 1, curses.ACS_HLINE, width-2 )
+            self.setTitle( title )
+
+        def setTitle( self, title ):
+            self.decoration.setText( 1, 1, title.center( self.dimensions[WIDTH]-2 ), curses.A_BOLD )
+
+    #-------------------------------------------------------------------------#
+#    class TitleWindow( Window ):
+    #-------------------------------------------------------------------------#
+#        """Title Window"""
+#        def __init__( self, x, y, width, height ):
+#            NCursesUI.Window.__init__( self, x, y, width, height )
+#            version = bb.__version__
+#            title = "BitBake %s" % version
+#            credit = "(C) 2003-2007 Team BitBake"
+#            #self.win.hline( 2, 1, curses.ACS_HLINE, width-2 )
+#            self.win.border()
+#            self.setText( 1, 1, title.center( self.dimensions[WIDTH]-2 ), curses.A_BOLD )
+#            self.setText( 1, 2, credit.center( self.dimensions[WIDTH]-2 ), curses.A_BOLD )
+
+    #-------------------------------------------------------------------------#
+    class ThreadActivityWindow( DecoratedWindow ):
+    #-------------------------------------------------------------------------#
+        """Thread Activity Window"""
+        def __init__( self, x, y, width, height ):
+            NCursesUI.DecoratedWindow.__init__( self, "Thread Activity", x, y, width, height )
+
+        def setStatus( self, thread, text ):
+            line = "%02d: %s" % ( thread, text )
+            width = self.dimensions[WIDTH]
+            if ( len(line) > width ):
+                line = line[:width-3] + "..."
+            else:
+                line = line.ljust( width )
+            self.setText( 0, thread, line )
+
+    #-------------------------------------------------------------------------#
+    class MainWindow( DecoratedWindow ):
+    #-------------------------------------------------------------------------#
+        """Main Window"""
+        def __init__( self, x, y, width, height ):
+            self.StatusPosition = width - MAXSTATUSLENGTH
+            NCursesUI.DecoratedWindow.__init__( self, None, x, y, width, height )
+            curses.nl()
+
+        def setTitle( self, title ):
+            title = "BitBake %s" % bb.__version__
+            self.decoration.setText( 2, 1, title, curses.A_BOLD )
+            self.decoration.setText( self.StatusPosition - 8, 1, "Status:", curses.A_BOLD )
+
+        def setStatus(self, status):
+            while len(status) < MAXSTATUSLENGTH:
+                status = status + " "
+            self.decoration.setText( self.StatusPosition, 1, status, curses.A_BOLD )
+
+
+    #-------------------------------------------------------------------------#
+    class ShellOutputWindow( DecoratedWindow ):
+    #-------------------------------------------------------------------------#
+        """Interactive Command Line Output"""
+        def __init__( self, x, y, width, height ):
+            NCursesUI.DecoratedWindow.__init__( self, "Command Line Window", x, y, width, height )
+
+    #-------------------------------------------------------------------------#
+    class ShellInputWindow( Window ):
+    #-------------------------------------------------------------------------#
+        """Interactive Command Line Input"""
+        def __init__( self, x, y, width, height ):
+            NCursesUI.Window.__init__( self, x, y, width, height )
+
+# put that to the top again from curses.textpad import Textbox
+#            self.textbox = Textbox( self.win )
+#            t = threading.Thread()
+#            t.run = self.textbox.edit
+#            t.start()
+
+    #-------------------------------------------------------------------------#
+    def main(self, stdscr, server, eventHandler):
+    #-------------------------------------------------------------------------#
+        height, width = stdscr.getmaxyx()
+
+        # for now split it like that:
+        # MAIN_y + THREAD_y = 2/3 screen at the top
+        # MAIN_x = 2/3 left, THREAD_y = 1/3 right
+        # CLI_y = 1/3 of screen at the bottom
+        # CLI_x = full
+
+        main_left = 0
+        main_top = 0
+        main_height = ( height // 3 * 2 )
+        main_width = ( width // 3 ) * 2
+        clo_left = main_left
+        clo_top = main_top + main_height
+        clo_height = height - main_height - main_top - 1
+        clo_width = width
+        cli_left = main_left
+        cli_top = clo_top + clo_height
+        cli_height = 1
+        cli_width = width
+        thread_left = main_left + main_width
+        thread_top = main_top
+        thread_height = main_height
+        thread_width = width - main_width
+
+        #tw = self.TitleWindow( 0, 0, width, main_top )
+        mw = self.MainWindow( main_left, main_top, main_width, main_height )
+        taw = self.ThreadActivityWindow( thread_left, thread_top, thread_width, thread_height )
+        clo = self.ShellOutputWindow( clo_left, clo_top, clo_width, clo_height )
+        cli = self.ShellInputWindow( cli_left, cli_top, cli_width, cli_height )
+        cli.setText( 0, 0, "BB>" )
+
+        mw.setStatus("Idle")
+
+        helper = uihelper.BBUIHelper()
+        shutdown = 0
+
+        try:
+            cmdline = server.runCommand(["getCmdLineAction"])
+            if not cmdline:
+                return
+            ret = server.runCommand(cmdline)
+            if ret != True:
+                print("Couldn't get default commandlind! %s" % ret)
+                return
+        except xmlrpclib.Fault as x:
+            print("XMLRPC Fault getting commandline:\n %s" % x)
+            return
+
+        exitflag = False
+        while not exitflag:
+            try:
+                event = eventHandler.waitEvent(0.25)
+                if not event:
+                    continue
+                helper.eventHandler(event)
+                #mw.appendText("%s\n" % event[0])
+                if isinstance(event, bb.build.TaskBase):
+                    mw.appendText("NOTE: %s\n" % event._message)
+                if isinstance(event, bb.msg.MsgDebug):
+                    mw.appendText('DEBUG: ' + event._message + '\n')
+                if isinstance(event, bb.msg.MsgNote):
+                    mw.appendText('NOTE: ' + event._message + '\n')
+                if isinstance(event, bb.msg.MsgWarn):
+                    mw.appendText('WARNING: ' + event._message + '\n')
+                if isinstance(event, bb.msg.MsgError):
+                    mw.appendText('ERROR: ' + event._message + '\n')
+                if isinstance(event, bb.msg.MsgFatal):
+                    mw.appendText('FATAL: ' + event._message + '\n')
+                if isinstance(event, bb.event.ParseProgress):
+                    x = event.sofar
+                    y = event.total
+                    if x == y:
+                        mw.setStatus("Idle")
+                        mw.appendText("Parsing finished. %d cached, %d parsed, %d skipped, %d masked."
+                                % ( event.cached, event.parsed, event.skipped, event.masked ))
+                    else:
+                        mw.setStatus("Parsing: %s (%04d/%04d) [%2d %%]" % ( next(parsespin), x, y, x*100//y ) )
+#                if isinstance(event, bb.build.TaskFailed):
+#                    if event.logfile:
+#                        if data.getVar("BBINCLUDELOGS", d):
+#                            bb.msg.error(bb.msg.domain.Build, "log data follows (%s)" % logfile)
+#                            number_of_lines = data.getVar("BBINCLUDELOGS_LINES", d)
+#                            if number_of_lines:
+#                                os.system('tail -n%s %s' % (number_of_lines, logfile))
+#                            else:
+#                                f = open(logfile, "r")
+#                                while True:
+#                                    l = f.readline()
+#                                    if l == '':
+#                                        break
+#                                    l = l.rstrip()
+#                                    print '| %s' % l
+#                                f.close()
+#                        else:
+#                            bb.msg.error(bb.msg.domain.Build, "see log in %s" % logfile)
+
+                if isinstance(event, bb.command.CookerCommandCompleted):
+                    exitflag = True
+                if isinstance(event, bb.command.CookerCommandFailed):
+                    mw.appendText("Command execution failed: %s" % event.error)
+                    time.sleep(2)
+                    exitflag = True
+                if isinstance(event, bb.cooker.CookerExit):
+                    exitflag = True
+
+                if helper.needUpdate:
+                    activetasks, failedtasks = helper.getTasks()
+                    taw.erase()
+                    taw.setText(0, 0, "")
+                    if activetasks:
+                        taw.appendText("Active Tasks:\n")
+                        for task in activetasks.itervalues():
+                            taw.appendText(task["title"])
+                    if failedtasks:
+                        taw.appendText("Failed Tasks:\n")
+                        for task in failedtasks:
+                            taw.appendText(task["title"])
+
+                curses.doupdate()
+            except KeyboardInterrupt:
+                if shutdown == 2:
+                    mw.appendText("Third Keyboard Interrupt, exit.\n")
+                    exitflag = True
+                if shutdown == 1:
+                    mw.appendText("Second Keyboard Interrupt, stopping...\n")
+                    server.runCommand(["stateStop"])
+                if shutdown == 0:
+                    mw.appendText("Keyboard Interrupt, closing down...\n")
+                    server.runCommand(["stateShutdown"])
+                shutdown = shutdown + 1
+                pass
+
+def init(server, eventHandler):
+    if not os.isatty(sys.stdout.fileno()):
+        print("FATAL: Unable to run 'ncurses' UI without a TTY.")
+        return
+    ui = NCursesUI()
+    try:
+        curses.wrapper(ui.main, server, eventHandler)
+    except:
+        import traceback
+        traceback.print_exc()
--- a/bitbake/lib/bb/ui/puccho.py
+++ b/bitbake/lib/bb/ui/puccho.py
@@ -0,0 +1,425 @@
+#
+# BitBake Graphical GTK User Interface
+#
+# Copyright (C) 2008        Intel Corporation
+#
+# Authored by Rob Bradford <rob@linux.intel.com>
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License version 2 as
+# published by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License along
+# with this program; if not, write to the Free Software Foundation, Inc.,
+# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+
+import gtk
+import gobject
+import gtk.glade
+import threading
+import urllib2
+import os
+import contextlib
+
+from bb.ui.crumbs.buildmanager import BuildManager, BuildConfiguration
+from bb.ui.crumbs.buildmanager import BuildManagerTreeView
+
+from bb.ui.crumbs.runningbuild import RunningBuild, RunningBuildTreeView
+
+# The metadata loader is used by the BuildSetupDialog to download the
+# available options to populate the dialog
+class MetaDataLoader(gobject.GObject):
+    """ This class provides the mechanism for loading the metadata (the
+    fetching and parsing) from a given URL. The metadata encompasses details
+    on what machines are available. The distribution and images available for
+    the machine and the the uris to use for building the given machine."""
+    __gsignals__ = {
+        'success' : (gobject.SIGNAL_RUN_LAST,
+                     gobject.TYPE_NONE,
+                     ()),
+        'error' : (gobject.SIGNAL_RUN_LAST,
+                   gobject.TYPE_NONE,
+                   (gobject.TYPE_STRING,))
+        }
+
+    # We use these little helper functions to ensure that we take the gdk lock
+    # when emitting the signal. These functions are called as idles (so that
+    # they happen in the gtk / main thread's main loop.
+    def emit_error_signal (self, remark):
+        gtk.gdk.threads_enter()
+        self.emit ("error", remark)
+        gtk.gdk.threads_leave()
+
+    def emit_success_signal (self):
+        gtk.gdk.threads_enter()
+        self.emit ("success")
+        gtk.gdk.threads_leave()
+
+    def __init__ (self):
+        gobject.GObject.__init__ (self)
+
+    class LoaderThread(threading.Thread):
+        """ This class provides an asynchronous loader for the metadata (by
+        using threads and signals). This is useful since the metadata may be
+        at a remote URL."""
+        class LoaderImportException (Exception):
+            pass
+
+        def __init__(self, loader, url):
+            threading.Thread.__init__ (self)
+            self.url = url
+            self.loader = loader
+
+        def run (self):
+            result = {}
+            try:
+                with contextlib.closing (urllib2.urlopen (self.url)) as f:
+                    # Parse the metadata format. The format is....
+                    # <machine>;<default distro>|<distro>...;<default image>|<image>...;<type##url>|...
+                    for line in f:
+                        components = line.split(";")
+                        if (len (components) < 4):
+                            raise MetaDataLoader.LoaderThread.LoaderImportException
+                        machine = components[0]
+                        distros = components[1].split("|")
+                        images = components[2].split("|")
+                        urls = components[3].split("|")
+
+                        result[machine] = (distros, images, urls)
+
+                # Create an object representing this *potential*
+                # configuration. It can become concrete if the machine, distro
+                # and image are all chosen in the UI
+                configuration = BuildConfiguration()
+                configuration.metadata_url = self.url
+                configuration.machine_options = result
+                self.loader.configuration = configuration
+
+                # Emit that we've actually got a configuration
+                gobject.idle_add (MetaDataLoader.emit_success_signal,
+                    self.loader)
+
+            except MetaDataLoader.LoaderThread.LoaderImportException as e:
+                gobject.idle_add (MetaDataLoader.emit_error_signal, self.loader,
+                    "Repository metadata corrupt")
+            except Exception as e:
+                gobject.idle_add (MetaDataLoader.emit_error_signal, self.loader,
+                    "Unable to download repository metadata")
+                print(e)
+
+    def try_fetch_from_url (self, url):
+        # Try and download the metadata. Firing a signal if successful
+        thread = MetaDataLoader.LoaderThread(self, url)
+        thread.start()
+
+class BuildSetupDialog (gtk.Dialog):
+    RESPONSE_BUILD = 1
+
+    # A little helper method that just sets the states on the widgets based on
+    # whether we've got good metadata or not.
+    def set_configurable (self, configurable):
+        if (self.configurable == configurable):
+            return
+
+        self.configurable = configurable
+        for widget in self.conf_widgets:
+            widget.set_sensitive (configurable)
+
+        if not configurable:
+            self.machine_combo.set_active (-1)
+            self.distribution_combo.set_active (-1)
+            self.image_combo.set_active (-1)
+
+    # GTK widget callbacks
+    def refresh_button_clicked (self, button):
+        # Refresh button clicked.
+
+        url = self.location_entry.get_chars (0, -1)
+        self.loader.try_fetch_from_url(url)
+
+    def repository_entry_editable_changed (self, entry):
+        if (len (entry.get_chars (0, -1)) > 0):
+            self.refresh_button.set_sensitive (True)
+        else:
+            self.refresh_button.set_sensitive (False)
+            self.clear_status_message()
+
+        # If we were previously configurable we are no longer since the
+        # location entry has been changed
+        self.set_configurable (False)
+
+    def machine_combo_changed (self, combobox):
+        active_iter = combobox.get_active_iter()
+
+        if not active_iter:
+            return
+
+        model = combobox.get_model()
+
+        if model:
+            chosen_machine = model.get (active_iter, 0)[0]
+
+        (distros_model, images_model) = \
+            self.loader.configuration.get_distro_and_images_models (chosen_machine)
+
+        self.distribution_combo.set_model (distros_model)
+        self.image_combo.set_model (images_model)
+
+    # Callbacks from the loader
+    def loader_success_cb (self, loader):
+        self.status_image.set_from_icon_name ("info",
+            gtk.ICON_SIZE_BUTTON)
+        self.status_image.show()
+        self.status_label.set_label ("Repository metadata successfully downloaded")
+
+        # Set the models on the combo boxes based on the models generated from
+        # the configuration that the loader has created
+
+        # We just need to set the machine here, that then determines the
+        # distro and image options. Cunning huh? :-)
+
+        self.configuration = self.loader.configuration
+        model = self.configuration.get_machines_model ()
+        self.machine_combo.set_model (model)
+
+        self.set_configurable (True)
+
+    def loader_error_cb (self, loader, message):
+        self.status_image.set_from_icon_name ("error",
+            gtk.ICON_SIZE_BUTTON)
+        self.status_image.show()
+        self.status_label.set_text ("Error downloading repository metadata")
+        for widget in self.conf_widgets:
+            widget.set_sensitive (False)
+
+    def clear_status_message (self):
+        self.status_image.hide()
+        self.status_label.set_label (
+            """<i>Enter the repository location and press _Refresh</i>""")
+
+    def __init__ (self):
+        gtk.Dialog.__init__ (self)
+
+        # Cancel
+        self.add_button (gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL)
+
+        # Build
+        button = gtk.Button ("_Build", None, True)
+        image = gtk.Image ()
+        image.set_from_stock (gtk.STOCK_EXECUTE, gtk.ICON_SIZE_BUTTON)
+        button.set_image (image)
+        self.add_action_widget (button, BuildSetupDialog.RESPONSE_BUILD)
+        button.show_all ()
+
+        # Pull in *just* the table from the Glade XML data.
+        gxml = gtk.glade.XML (os.path.dirname(__file__) + "/crumbs/puccho.glade",
+            root = "build_table")
+        table = gxml.get_widget ("build_table")
+        self.vbox.pack_start (table, True, False, 0)
+
+        # Grab all the widgets that we need to turn on/off when we refresh...
+        self.conf_widgets = []
+        self.conf_widgets += [gxml.get_widget ("machine_label")]
+        self.conf_widgets += [gxml.get_widget ("distribution_label")]
+        self.conf_widgets += [gxml.get_widget ("image_label")]
+        self.conf_widgets += [gxml.get_widget ("machine_combo")]
+        self.conf_widgets += [gxml.get_widget ("distribution_combo")]
+        self.conf_widgets += [gxml.get_widget ("image_combo")]
+
+        # Grab the status widgets
+        self.status_image = gxml.get_widget ("status_image")
+        self.status_label = gxml.get_widget ("status_label")
+
+        # Grab the refresh button and connect to the clicked signal
+        self.refresh_button = gxml.get_widget ("refresh_button")
+        self.refresh_button.connect ("clicked", self.refresh_button_clicked)
+
+        # Grab the location entry and connect to editable::changed
+        self.location_entry = gxml.get_widget ("location_entry")
+        self.location_entry.connect ("changed",
+            self.repository_entry_editable_changed)
+
+        # Grab the machine combo and hook onto the changed signal. This then
+        # allows us to populate the distro and image combos
+        self.machine_combo = gxml.get_widget ("machine_combo")
+        self.machine_combo.connect ("changed", self.machine_combo_changed)
+
+        # Setup the combo
+        cell = gtk.CellRendererText()
+        self.machine_combo.pack_start(cell, True)
+        self.machine_combo.add_attribute(cell, 'text', 0)
+
+        # Grab the distro and image combos. We need these to populate with
+        # models once the machine is chosen
+        self.distribution_combo = gxml.get_widget ("distribution_combo")
+        cell = gtk.CellRendererText()
+        self.distribution_combo.pack_start(cell, True)
+        self.distribution_combo.add_attribute(cell, 'text', 0)
+
+        self.image_combo = gxml.get_widget ("image_combo")
+        cell = gtk.CellRendererText()
+        self.image_combo.pack_start(cell, True)
+        self.image_combo.add_attribute(cell, 'text', 0)
+
+        # Put the default descriptive text in the status box
+        self.clear_status_message()
+
+        # Mark as non-configurable, this is just greys out the widgets the
+        # user can't yet use
+        self.configurable = False
+        self.set_configurable(False)
+
+        # Show the table
+        table.show_all ()
+
+        # The loader and some signals connected to it to update the status
+        # area
+        self.loader = MetaDataLoader()
+        self.loader.connect ("success", self.loader_success_cb)
+        self.loader.connect ("error", self.loader_error_cb)
+
+    def update_configuration (self):
+        """ A poorly named function but it updates the internal configuration
+        from the widgets. This can make that configuration concrete and can
+        thus be used for building """
+        # Extract the chosen machine from the combo
+        model = self.machine_combo.get_model()
+        active_iter = self.machine_combo.get_active_iter()
+        if (active_iter):
+            self.configuration.machine = model.get(active_iter, 0)[0]
+
+        # Extract the chosen distro from the combo
+        model = self.distribution_combo.get_model()
+        active_iter = self.distribution_combo.get_active_iter()
+        if (active_iter):
+            self.configuration.distro = model.get(active_iter, 0)[0]
+
+        # Extract the chosen image from the combo
+        model = self.image_combo.get_model()
+        active_iter = self.image_combo.get_active_iter()
+        if (active_iter):
+            self.configuration.image = model.get(active_iter, 0)[0]
+
+# This function operates to pull events out from the event queue and then push
+# them into the RunningBuild (which then drives the RunningBuild which then
+# pushes through and updates the progress tree view.)
+#
+# TODO: Should be a method on the RunningBuild class
+def event_handle_timeout (eventHandler, build):
+    # Consume as many messages as we can ...
+    event = eventHandler.getEvent()
+    while event:
+        build.handle_event (event)
+        event = eventHandler.getEvent()
+    return True
+
+class MainWindow (gtk.Window):
+
+    # Callback that gets fired when the user hits a button in the
+    # BuildSetupDialog.
+    def build_dialog_box_response_cb (self, dialog, response_id):
+        conf = None
+        if (response_id == BuildSetupDialog.RESPONSE_BUILD):
+            dialog.update_configuration()
+            print(dialog.configuration.machine, dialog.configuration.distro, \
+                dialog.configuration.image)
+            conf = dialog.configuration
+
+        dialog.destroy()
+
+        if conf:
+            self.manager.do_build (conf)
+
+    def build_button_clicked_cb (self, button):
+        dialog = BuildSetupDialog ()
+
+        # For some unknown reason Dialog.run causes nice little deadlocks ... :-(
+        dialog.connect ("response", self.build_dialog_box_response_cb)
+        dialog.show()
+
+    def __init__ (self):
+        gtk.Window.__init__ (self)
+
+        # Pull in *just* the main vbox from the Glade XML data and then pack
+        # that inside the window
+        gxml = gtk.glade.XML (os.path.dirname(__file__) + "/crumbs/puccho.glade",
+            root = "main_window_vbox")
+        vbox = gxml.get_widget ("main_window_vbox")
+        self.add (vbox)
+
+        # Create the tree views for the build manager view and the progress view
+        self.build_manager_view = BuildManagerTreeView()
+        self.running_build_view = RunningBuildTreeView()
+
+        # Grab the scrolled windows that we put the tree views into
+        self.results_scrolledwindow = gxml.get_widget ("results_scrolledwindow")
+        self.progress_scrolledwindow = gxml.get_widget ("progress_scrolledwindow")
+
+        # Put the tree views inside ...
+        self.results_scrolledwindow.add (self.build_manager_view)
+        self.progress_scrolledwindow.add (self.running_build_view)
+
+        # Hook up the build button...
+        self.build_button = gxml.get_widget ("main_toolbutton_build")
+        self.build_button.connect ("clicked", self.build_button_clicked_cb)
+
+# I'm not very happy about the current ownership of the RunningBuild. I have
+# my suspicions that this object should be held by the BuildManager since we
+# care about the signals in the manager
+
+def running_build_succeeded_cb (running_build, manager):
+    # Notify the manager that a build has succeeded. This is necessary as part
+    # of the 'hack' that we use for making the row in the model / view
+    # representing the ongoing build change into a row representing the
+    # completed build. Since we know only one build can be running a time then
+    # we can handle this.
+
+    # FIXME: Refactor all this so that the RunningBuild is owned by the
+    # BuildManager. It can then hook onto the signals directly and drive
+    # interesting things it cares about.
+    manager.notify_build_succeeded ()
+    print("build succeeded")
+
+def running_build_failed_cb (running_build, manager):
+    # As above
+    print("build failed")
+    manager.notify_build_failed ()
+
+def init (server, eventHandler):
+    # Initialise threading...
+    gobject.threads_init()
+    gtk.gdk.threads_init()
+
+    main_window = MainWindow ()
+    main_window.show_all ()
+
+    # Set up the build manager stuff in general
+    builds_dir = os.path.join (os.getcwd(),  "results")
+    manager = BuildManager (server, builds_dir)
+    main_window.build_manager_view.set_model (manager.model)
+
+    # Do the running build setup
+    running_build = RunningBuild ()
+    main_window.running_build_view.set_model (running_build.model)
+    running_build.connect ("build-succeeded", running_build_succeeded_cb,
+        manager)
+    running_build.connect ("build-failed", running_build_failed_cb, manager)
+
+    # We need to save the manager into the MainWindow so that the toolbar
+    # button can use it.
+    # FIXME: Refactor ?
+    main_window.manager = manager
+
+    # Use a timeout function for probing the event queue to find out if we
+    # have a message waiting for us.
+    gobject.timeout_add (200,
+                         event_handle_timeout,
+                         eventHandler,
+                         running_build)
+
+    gtk.main()
--- a/bitbake/lib/bb/ui/uievent.py
+++ b/bitbake/lib/bb/ui/uievent.py
@@ -0,0 +1,124 @@
+# ex:ts=4:sw=4:sts=4:et
+# -*- tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*-
+#
+# Copyright (C) 2006 - 2007  Michael 'Mickey' Lauer
+# Copyright (C) 2006 - 2007  Richard Purdie
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License version 2 as
+# published by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License along
+# with this program; if not, write to the Free Software Foundation, Inc.,
+# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+
+
+"""
+Use this class to fork off a thread to recieve event callbacks from the bitbake
+server and queue them for the UI to process. This process must be used to avoid
+client/server deadlocks.
+"""
+
+import socket, threading, pickle
+from SimpleXMLRPCServer import SimpleXMLRPCServer, SimpleXMLRPCRequestHandler
+
+class BBUIEventQueue:
+    def __init__(self, BBServer):
+
+        self.eventQueue = []
+        self.eventQueueLock = threading.Lock()
+        self.eventQueueNotify = threading.Event()
+
+        self.BBServer = BBServer
+
+        self.t = threading.Thread()
+        self.t.setDaemon(True)
+        self.t.run = self.startCallbackHandler
+        self.t.start()
+
+    def getEvent(self):
+
+        self.eventQueueLock.acquire()
+
+        if len(self.eventQueue) == 0:
+            self.eventQueueLock.release()
+            return None
+
+        item = self.eventQueue.pop(0)
+
+        if len(self.eventQueue) == 0:
+            self.eventQueueNotify.clear()
+
+        self.eventQueueLock.release()
+        return item
+
+    def waitEvent(self, delay):
+        self.eventQueueNotify.wait(delay)
+        return self.getEvent()
+
+    def queue_event(self, event):
+        self.eventQueueLock.acquire()
+        self.eventQueue.append(pickle.loads(event))
+        self.eventQueueNotify.set()
+        self.eventQueueLock.release()
+
+    def startCallbackHandler(self):
+
+        server = UIXMLRPCServer()
+        self.host, self.port = server.socket.getsockname()
+
+        server.register_function( self.system_quit, "event.quit" )
+        server.register_function( self.queue_event, "event.send" )
+        server.socket.settimeout(1)
+
+        self.EventHandle = self.BBServer.registerEventHandler(self.host, self.port)
+
+        self.server = server
+        while not server.quit:
+            server.handle_request()
+        server.server_close()
+
+    def system_quit( self ):
+        """
+        Shut down the callback thread
+        """
+        try:
+            self.BBServer.unregisterEventHandler(self.EventHandle)
+        except:
+            pass
+        self.server.quit = True
+
+class UIXMLRPCServer (SimpleXMLRPCServer):
+
+    def __init__( self, interface = ("localhost", 0) ):
+        self.quit = False
+        SimpleXMLRPCServer.__init__( self,
+                                    interface,
+                                    requestHandler=SimpleXMLRPCRequestHandler,
+                                    logRequests=False, allow_none=True)
+
+    def get_request(self):
+        while not self.quit:
+            try:
+                sock, addr = self.socket.accept()
+                sock.settimeout(1)
+                return (sock, addr)
+            except socket.timeout:
+                pass
+        return (None, None)
+
+    def close_request(self, request):
+        if request is None:
+            return
+        SimpleXMLRPCServer.close_request(self, request)
+
+    def process_request(self, request, client_address):
+        if request is None:
+            return
+        SimpleXMLRPCServer.process_request(self, request, client_address)
+
--- a/bitbake/lib/bb/ui/uihelper.py
+++ b/bitbake/lib/bb/ui/uihelper.py
@@ -0,0 +1,50 @@
+# ex:ts=4:sw=4:sts=4:et
+# -*- tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*-
+#
+# Copyright (C) 2006 - 2007  Michael 'Mickey' Lauer
+# Copyright (C) 2006 - 2007  Richard Purdie
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License version 2 as
+# published by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License along
+# with this program; if not, write to the Free Software Foundation, Inc.,
+# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+
+class BBUIHelper:
+    def __init__(self):
+        self.needUpdate = False
+        self.running_tasks = {}
+        self.failed_tasks = []
+
+    def eventHandler(self, event):
+        if isinstance(event, bb.build.TaskStarted):
+            self.running_tasks[event.pid] = { 'title' : "%s %s" % (event._package, event._task) }
+            self.needUpdate = True
+        if isinstance(event, bb.build.TaskSucceeded):
+            del self.running_tasks[event.pid]
+            self.needUpdate = True
+        if isinstance(event, bb.build.TaskFailed):
+            del self.running_tasks[event.pid]
+            self.failed_tasks.append( { 'title' : "%s %s" % (event._package, event._task)})
+            self.needUpdate = True
+
+        # Add runqueue event handling
+        #if isinstance(event, bb.runqueue.runQueueTaskCompleted):
+        #    a = 1
+        #if isinstance(event, bb.runqueue.runQueueTaskStarted):
+        #    a = 1
+        #if isinstance(event, bb.runqueue.runQueueTaskFailed):
+        #    a = 1
+        #if isinstance(event, bb.runqueue.runQueueExitWait):
+        #    a = 1
+
+    def getTasks(self):
+        self.needUpdate = False
+        return (self.running_tasks, self.failed_tasks)
--- a/bitbake/lib/bb/utils.py
+++ b/bitbake/lib/bb/utils.py
@@ -19,32 +19,47 @@ BitBake Utility Functions
 # with this program; if not, write to the Free Software Foundation, Inc.,
 # 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.

-digits = "0123456789"
-ascii_letters = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
+import re, fcntl, os, string, stat, shutil, time
+import sys
+import bb
+import errno
+import bb.msg
+from commands import getstatusoutput

-import re
+# Version comparison
+separators = ".-"
+
+# Context used in better_exec, eval
+_context = {
+    "os": os,
+    "bb": bb,
+    "time": time,
+}

 def explode_version(s):
    r = []
    alpha_regexp = re.compile('^([a-zA-Z]+)(.*)$')
    numeric_regexp = re.compile('^(\d+)(.*)$')
    while (s != ''):
-        if s[0] in digits:
+        if s[0] in string.digits:
            m = numeric_regexp.match(s)
            r.append(int(m.group(1)))
            s = m.group(2)
            continue
-        if s[0] in ascii_letters:
+        if s[0] in string.letters:
            m = alpha_regexp.match(s)
            r.append(m.group(1))
            s = m.group(2)
            continue
+        r.append(s[0])
        s = s[1:]
    return r

 def vercmp_part(a, b):
    va = explode_version(a)
    vb = explode_version(b)
+    sa = False
+    sb = False
    while True:
        if va == []:
            ca = None
@@ -56,6 +71,16 @@ def vercmp_part(a, b):
            cb = vb.pop(0)
        if ca == None and cb == None:
            return 0
+
+        if isinstance(ca, basestring):
+            sa = ca in separators
+        if isinstance(cb, basestring):
+            sb = cb in separators
+        if sa and not sb:
+            return -1
+        if not sa and sb:
+            return 1
+
        if ca > cb:
            return 1
        if ca < cb:
@@ -72,6 +97,131 @@ def vercmp(ta, tb):
        r = vercmp_part(ra, rb)
    return r

+_package_weights_ = {"pre":-2, "p":0, "alpha":-4, "beta":-3, "rc":-1}    # dicts are unordered
+_package_ends_ = ["pre", "p", "alpha", "beta", "rc", "cvs", "bk", "HEAD" ]            # so we need ordered list
+
+def relparse(myver):
+    """Parses the last elements of a version number into a triplet, that can
+    later be compared.
+    """
+
+    number = 0
+    p1 = 0
+    p2 = 0
+    mynewver = myver.split('_')
+    if len(mynewver) == 2:
+        # an _package_weights_
+        number = float(mynewver[0])
+        match = 0
+        for x in _package_ends_:
+            elen = len(x)
+            if mynewver[1][:elen] == x:
+                match = 1
+                p1 = _package_weights_[x]
+                try:
+                    p2 = float(mynewver[1][elen:])
+                except:
+                    p2 = 0
+                break
+        if not match:
+            # normal number or number with letter at end
+            divider = len(myver)-1
+            if myver[divider:] not in "1234567890":
+                # letter at end
+                p1 = ord(myver[divider:])
+                number = float(myver[0:divider])
+            else:
+                number = float(myver)
+    else:
+        # normal number or number with letter at end
+        divider = len(myver)-1
+        if myver[divider:] not in "1234567890":
+            #letter at end
+            p1 = ord(myver[divider:])
+            number = float(myver[0:divider])
+        else:
+            number = float(myver)
+    return [number, p1, p2]
+
+__vercmp_cache__ = {}
+
+def vercmp_string(val1, val2):
+    """This takes two version strings and returns an integer to tell you whether
+    the versions are the same, val1>val2 or val2>val1.
+    """
+
+    # quick short-circuit
+    if val1 == val2:
+        return 0
+    valkey = val1 + " " + val2
+
+    # cache lookup
+    try:
+        return __vercmp_cache__[valkey]
+        try:
+            return - __vercmp_cache__[val2 + " " + val1]
+        except KeyError:
+            pass
+    except KeyError:
+        pass
+
+    # consider 1_p2 vc 1.1
+    # after expansion will become (1_p2,0) vc (1,1)
+    # then 1_p2 is compared with 1 before 0 is compared with 1
+    # to solve the bug we need to convert it to (1,0_p2)
+    # by splitting _prepart part and adding it back _after_expansion
+
+    val1_prepart = val2_prepart = ''
+    if val1.count('_'):
+        val1, val1_prepart = val1.split('_', 1)
+    if val2.count('_'):
+        val2, val2_prepart = val2.split('_', 1)
+
+    # replace '-' by '.'
+    # FIXME: Is it needed? can val1/2 contain '-'?
+
+    val1 = val1.split("-")
+    if len(val1) == 2:
+        val1[0] = val1[0] + "." + val1[1]
+    val2 = val2.split("-")
+    if len(val2) == 2:
+        val2[0] = val2[0] + "." + val2[1]
+
+    val1 = val1[0].split('.')
+    val2 = val2[0].split('.')
+
+    # add back decimal point so that .03 does not become "3" !
+    for x in range(1, len(val1)):
+        if val1[x][0] == '0' :
+            val1[x] = '.' + val1[x]
+    for x in range(1, len(val2)):
+        if val2[x][0] == '0' :
+            val2[x] = '.' + val2[x]
+
+    # extend varion numbers
+    if len(val2) < len(val1):
+        val2.extend(["0"]*(len(val1)-len(val2)))
+    elif len(val1) < len(val2):
+        val1.extend(["0"]*(len(val2)-len(val1)))
+
+    # add back _prepart tails
+    if val1_prepart:
+        val1[-1] += '_' + val1_prepart
+    if val2_prepart:
+        val2[-1] += '_' + val2_prepart
+    # The above code will extend version numbers out so they
+    # have the same number of digits.
+    for x in range(0, len(val1)):
+        cmp1 = relparse(val1[x])
+        cmp2 = relparse(val2[x])
+        for y in range(0, 3):
+            myret = cmp1[y] - cmp2[y]
+            if myret != 0:
+                __vercmp_cache__[valkey] = myret
+                return myret
+    __vercmp_cache__[valkey] = 0
+    return 0
+
 def explode_deps(s):
    """
    Take an RDEPENDS style string of format:
@@ -85,53 +235,101 @@ def explode_deps(s):
    for i in l:
        if i[0] == '(':
            flag = True
-            j = []
-        if flag:
-            j.append(i)
-        else:
+            #j = []
+        if not flag:
            r.append(i)
+        #else:
+        #    j.append(i)
        if flag and i.endswith(')'):
            flag = False
            # Ignore version
            #r[-1] += ' ' + ' '.join(j)
    return r

+def explode_dep_versions(s):
+    """
+    Take an RDEPENDS style string of format:
+    "DEPEND1 (optional version) DEPEND2 (optional version) ..."
+    and return a dictionary of dependencies and versions.
+    """
+    r = {}
+    l = s.replace(",", "").split()
+    lastdep = None
+    lastver = ""
+    inversion = False
+    for i in l:
+        if i[0] == '(':
+            inversion = True
+            lastver = i[1:] or ""
+            #j = []
+        elif inversion and i.endswith(')'):
+            inversion = False
+            lastver = lastver + " " + (i[:-1] or "")
+            r[lastdep] = lastver
+        elif not inversion:
+            r[i] = None
+            lastdep = i
+            lastver = ""
+        elif inversion:
+            lastver = lastver + " " + i

+    return r
+
+def join_deps(deps):
+    """
+    Take the result from explode_dep_versions and generate a dependency string
+    """
+    result = []
+    for dep in deps:
+        if deps[dep]:
+            result.append(dep + " (" + deps[dep] + ")")
+        else:
+            result.append(dep)
+    return ", ".join(result)
+
+def extend_deps(dest, src):
+    """
+    Extend the results from explode_dep_versions by appending all of the items
+    in the second list, avoiding duplicates.
+    """
+    for dep in src:
+        if dep not in dest:
+            dest[dep] = src[dep]
+        elif dest[dep] != src[dep]:
+            dest[dep] = src[dep]

 def _print_trace(body, line):
    """
    Print the Environment of a Text Body
    """
-    import bb
-
    # print the environment of the method
-    bb.msg.error(bb.msg.domain.Util, "Printing the environment of the function")
-    min_line = max(1,line-4)
-    max_line = min(line+4,len(body)-1)
-    for i in range(min_line,max_line+1):
+    min_line = max(1, line-4)
+    max_line = min(line + 4, len(body)-1)
+    for i in range(min_line, max_line + 1):
        bb.msg.error(bb.msg.domain.Util, "\t%.4d:%s" % (i, body[i-1]) )


-def better_compile(text, file, realfile):
+def better_compile(text, file, realfile, mode = "exec"):
    """
    A better compile method. This method
    will print  the offending lines.
    """
    try:
-        return compile(text, file, "exec")
-    except Exception, e:
-        import bb,sys
-
+        return compile(text, file, mode)
+    except Exception as e:
        # split the text into lines again
        body = text.split('\n')
-        bb.msg.error(bb.msg.domain.Util, "Error in compiling: ", realfile)
-        bb.msg.error(bb.msg.domain.Util, "The lines resulting into this error were:")
-        bb.msg.error(bb.msg.domain.Util, "\t%d:%s:'%s'" % (e.lineno, e.__class__.__name__, body[e.lineno-1]))
-
-        _print_trace(body, e.lineno)
-
-        # exit now
-        sys.exit(1)
+        bb.msg.error(bb.msg.domain.Util, "Error in compiling python function in: %s" % (realfile))
+        bb.msg.error(bb.msg.domain.Util, str(e))
+        if e.lineno:
+            bb.msg.error(bb.msg.domain.Util, "The lines leading to this error were:")
+            bb.msg.error(bb.msg.domain.Util, "\t%d:%s:'%s'" % (e.lineno, e.__class__.__name__, body[e.lineno-1]))
+            _print_trace(body, e.lineno)
+        else:
+            bb.msg.error(bb.msg.domain.Util, "The function causing this error was:")
+            for line in body:
+                bb.msg.error(bb.msg.domain.Util, line)
+        raise

 def better_exec(code, context, text, realfile):
    """
@@ -139,66 +337,426 @@ def better_exec(code, context, text, realfile):
    print the lines that are responsible for the
    error.
    """
-    import bb,sys
+    import bb.parse
    try:
-        exec code in context
+        exec(code, _context, context)
    except:
-        (t,value,tb) = sys.exc_info()
+        (t, value, tb) = sys.exc_info()

        if t in [bb.parse.SkipPackage, bb.build.FuncFailed]:
            raise

        # print the Header of the Error Message
-        bb.msg.error(bb.msg.domain.Util, "Error in executing: ", realfile)
-        bb.msg.error(bb.msg.domain.Util, "Exception:%s Message:%s" % (t,value) )
+        bb.msg.error(bb.msg.domain.Util, "Error in executing python function in: %s" % realfile)
+        bb.msg.error(bb.msg.domain.Util, "Exception:%s Message:%s" % (t, value))

-        # let us find the line number now
-        while tb.tb_next:
-            tb = tb.tb_next
+        # Strip 'us' from the stack (better_exec call)
+        tb = tb.tb_next

        import traceback
-        line = traceback.tb_lineno(tb)
+        tbextract = traceback.extract_tb(tb)
+        tbextract = "\n".join(traceback.format_list(tbextract))
+        bb.msg.error(bb.msg.domain.Util, "Traceback:")
+        for line in tbextract.split('\n'):
+            bb.msg.error(bb.msg.domain.Util, line)

+        line = traceback.tb_lineno(tb)
+        bb.msg.error(bb.msg.domain.Util, "The lines leading to this error were:")
        _print_trace( text.split('\n'), line )
-        
+
        raise

-def Enum(*names):
-   """
-   A simple class to give Enum support
-   """
+def simple_exec(code, context):
+    exec(code, _context, context)

-   assert names, "Empty enums are not supported"
+def better_eval(source, locals):
+    return eval(source, _context, locals)

-   class EnumClass(object):
-      __slots__ = names
-      def __iter__(self):        return iter(constants)
-      def __len__(self):         return len(constants)
-      def __getitem__(self, i):  return constants[i]
-      def __repr__(self):        return 'Enum' + str(names)
-      def __str__(self):         return 'enum ' + str(constants)
+def lockfile(name):
+    """
+    Use the file fn as a lock file, return when the lock has been acquired.
+    Returns a variable to pass to unlockfile().
+    """
+    path = os.path.dirname(name)
+    if not os.path.isdir(path):
+        bb.msg.error(bb.msg.domain.Util, "Error, lockfile path does not exist!: %s" % path)
+        sys.exit(1)

-   class EnumValue(object):
-      __slots__ = ('__value')
-      def __init__(self, value): self.__value = value
-      Value = property(lambda self: self.__value)
-      EnumType = property(lambda self: EnumType)
-      def __hash__(self):        return hash(self.__value)
-      def __cmp__(self, other):
-         # C fans might want to remove the following assertion
-         # to make all enums comparable by ordinal value {;))
-         assert self.EnumType is other.EnumType, "Only values from the same enum are comparable"
-         return cmp(self.__value, other.__value)
-      def __invert__(self):      return constants[maximum - self.__value]
-      def __nonzero__(self):     return bool(self.__value)
-      def __repr__(self):        return str(names[self.__value])
+    while True:
+        # If we leave the lockfiles lying around there is no problem
+        # but we should clean up after ourselves. This gives potential
+        # for races though. To work around this, when we acquire the lock
+        # we check the file we locked was still the lock file on disk.
+        # by comparing inode numbers. If they don't match or the lockfile
+        # no longer exists, we start again.

-   maximum = len(names) - 1
-   constants = [None] * len(names)
-   for i, each in enumerate(names):
-      val = EnumValue(i)
-      setattr(EnumClass, each, val)
-      constants[i] = val
-   constants = tuple(constants)
-   EnumType = EnumClass()
-   return EnumType
+        # This implementation is unfair since the last person to request the
+        # lock is the most likely to win it.
+
+        try:
+            lf = open(name, "a + ")
+            fcntl.flock(lf.fileno(), fcntl.LOCK_EX)
+            statinfo = os.fstat(lf.fileno())
+            if os.path.exists(lf.name):
+                statinfo2 = os.stat(lf.name)
+                if statinfo.st_ino == statinfo2.st_ino:
+                    return lf
+            # File no longer exists or changed, retry
+            lf.close
+        except Exception as e:
+            continue
+
+def unlockfile(lf):
+    """
+    Unlock a file locked using lockfile()
+    """
+    os.unlink(lf.name)
+    fcntl.flock(lf.fileno(), fcntl.LOCK_UN)
+    lf.close
+
+def md5_file(filename):
+    """
+    Return the hex string representation of the MD5 checksum of filename.
+    """
+    try:
+        import hashlib
+        m = hashlib.md5()
+    except ImportError:
+        import md5
+        m = md5.new()
+
+    for line in open(filename):
+        m.update(line)
+    return m.hexdigest()
+
+def sha256_file(filename):
+    """
+    Return the hex string representation of the 256-bit SHA checksum of
+    filename.  On Python 2.4 this will return None, so callers will need to
+    handle that by either skipping SHA checks, or running a standalone sha256sum
+    binary.
+    """
+    try:
+        import hashlib
+    except ImportError:
+        return None
+
+    s = hashlib.sha256()
+    for line in open(filename):
+        s.update(line)
+    return s.hexdigest()
+
+def preserved_envvars_list():
+    return [
+        'BBPATH',
+        'BB_PRESERVE_ENV',
+        'BB_ENV_WHITELIST',
+        'BB_ENV_EXTRAWHITE',
+        'BB_TASKHASH',
+        'COLORTERM',
+        'DBUS_SESSION_BUS_ADDRESS',
+        'DESKTOP_SESSION',
+        'DESKTOP_STARTUP_ID',
+        'DISPLAY',
+        'GNOME_KEYRING_PID',
+        'GNOME_KEYRING_SOCKET',
+        'GPG_AGENT_INFO',
+        'GTK_RC_FILES',
+        'HOME',
+        'LANG',
+        'LOGNAME',
+        'PATH',
+        'PWD',
+        'SESSION_MANAGER',
+        'SHELL',
+        'SSH_AUTH_SOCK',
+        'TERM',
+        'USER',
+        'USERNAME',
+        '_',
+        'XAUTHORITY',
+        'XDG_DATA_DIRS',
+        'XDG_SESSION_COOKIE',
+    ]
+
+def filter_environment(good_vars):
+    """
+    Create a pristine environment for bitbake. This will remove variables that
+    are not known and may influence the build in a negative way.
+    """
+
+    removed_vars = []
+    for key in os.environ.keys():
+        if key in good_vars:
+            continue
+
+        removed_vars.append(key)
+        os.unsetenv(key)
+        del os.environ[key]
+
+    if len(removed_vars):
+        bb.msg.debug(1, bb.msg.domain.Util, "Removed the following variables from the environment: %s" % (", ".join(removed_vars)))
+
+    return removed_vars
+
+def clean_environment():
+    """
+    Clean up any spurious environment variables. This will remove any
+    variables the user hasn't chose to preserve.
+    """
+    if 'BB_PRESERVE_ENV' not in os.environ:
+        if 'BB_ENV_WHITELIST' in os.environ:
+            good_vars = os.environ['BB_ENV_WHITELIST'].split()
+        else:
+            good_vars = preserved_envvars_list()
+        if 'BB_ENV_EXTRAWHITE' in os.environ:
+            good_vars.extend(os.environ['BB_ENV_EXTRAWHITE'].split())
+        filter_environment(good_vars)
+
+def empty_environment():
+    """
+    Remove all variables from the environment.
+    """
+    for s in os.environ.keys():
+        os.unsetenv(s)
+        del os.environ[s]
+
+def build_environment(d):
+    """
+    Build an environment from all exported variables.
+    """
+    import bb.data
+    for var in bb.data.keys(d):
+        export = bb.data.getVarFlag(var, "export", d)
+        if export:
+            os.environ[var] = bb.data.getVar(var, d, True) or ""
+
+def prunedir(topdir):
+    # Delete everything reachable from the directory named in 'topdir'.
+    # CAUTION:  This is dangerous!
+    for root, dirs, files in os.walk(topdir, topdown = False):
+        for name in files:
+            os.remove(os.path.join(root, name))
+        for name in dirs:
+            if os.path.islink(os.path.join(root, name)):
+                os.remove(os.path.join(root, name))
+            else:
+                os.rmdir(os.path.join(root, name))
+    os.rmdir(topdir)
+
+#
+# Could also use return re.compile("(%s)" % "|".join(map(re.escape, suffixes))).sub(lambda mo: "", var)
+# but thats possibly insane and suffixes is probably going to be small
+#
+def prune_suffix(var, suffixes, d):
+    # See if var ends with any of the suffixes listed and
+    # remove it if found
+    for suffix in suffixes:
+        if var.endswith(suffix):
+            return var.replace(suffix, "")
+    return var
+
+def mkdirhier(dir):
+    """Create a directory like 'mkdir -p', but does not complain if
+    directory already exists like os.makedirs
+    """
+
+    bb.msg.debug(3, bb.msg.domain.Util, "mkdirhier(%s)" % dir)
+    try:
+        os.makedirs(dir)
+        bb.msg.debug(2, bb.msg.domain.Util, "created " + dir)
+    except OSError as e:
+        if e.errno != errno.EEXIST:
+            raise e
+
+def movefile(src, dest, newmtime = None, sstat = None):
+    """Moves a file from src to dest, preserving all permissions and
+    attributes; mtime will be preserved even when moving across
+    filesystems.  Returns true on success and false on failure. Move is
+    atomic.
+    """
+
+    #print "movefile(" + src + "," + dest + "," + str(newmtime) + "," + str(sstat) + ")"
+    try:
+        if not sstat:
+            sstat = os.lstat(src)
+    except Exception as e:
+        print("movefile: Stating source file failed...", e)
+        return None
+
+    destexists = 1
+    try:
+        dstat = os.lstat(dest)
+    except:
+        dstat = os.lstat(os.path.dirname(dest))
+        destexists = 0
+
+    if destexists:
+        if stat.S_ISLNK(dstat[stat.ST_MODE]):
+            try:
+                os.unlink(dest)
+                destexists = 0
+            except Exception as e:
+                pass
+
+    if stat.S_ISLNK(sstat[stat.ST_MODE]):
+        try:
+            target = os.readlink(src)
+            if destexists and not stat.S_ISDIR(dstat[stat.ST_MODE]):
+                os.unlink(dest)
+            os.symlink(target, dest)
+            #os.lchown(dest,sstat[stat.ST_UID],sstat[stat.ST_GID])
+            os.unlink(src)
+            return os.lstat(dest)
+        except Exception as e:
+            print("movefile: failed to properly create symlink:", dest, "->", target, e)
+            return None
+
+    renamefailed = 1
+    if sstat[stat.ST_DEV] == dstat[stat.ST_DEV]:
+        try:
+            os.rename(src, dest)
+            renamefailed = 0
+        except Exception as e:
+            if e[0] != errno.EXDEV:
+                # Some random error.
+                print("movefile: Failed to move", src, "to", dest, e)
+                return None
+            # Invalid cross-device-link 'bind' mounted or actually Cross-Device
+
+    if renamefailed:
+        didcopy = 0
+        if stat.S_ISREG(sstat[stat.ST_MODE]):
+            try: # For safety copy then move it over.
+                shutil.copyfile(src, dest + "#new")
+                os.rename(dest + "#new", dest)
+                didcopy = 1
+            except Exception as e:
+                print('movefile: copy', src, '->', dest, 'failed.', e)
+                return None
+        else:
+            #we don't yet handle special, so we need to fall back to /bin/mv
+            a = getstatusoutput("/bin/mv -f " + "'" + src + "' '" + dest + "'")
+            if a[0] != 0:
+                print("movefile: Failed to move special file:" + src + "' to '" + dest + "'", a)
+                return None # failure
+        try:
+            if didcopy:
+                os.lchown(dest, sstat[stat.ST_UID], sstat[stat.ST_GID])
+                os.chmod(dest, stat.S_IMODE(sstat[stat.ST_MODE])) # Sticky is reset on chown
+                os.unlink(src)
+        except Exception as e:
+            print("movefile: Failed to chown/chmod/unlink", dest, e)
+            return None
+
+    if newmtime:
+        os.utime(dest, (newmtime, newmtime))
+    else:
+        os.utime(dest, (sstat[stat.ST_ATIME], sstat[stat.ST_MTIME]))
+        newmtime = sstat[stat.ST_MTIME]
+    return newmtime
+
+def copyfile(src, dest, newmtime = None, sstat = None):
+    """
+    Copies a file from src to dest, preserving all permissions and
+    attributes; mtime will be preserved even when moving across
+    filesystems.  Returns true on success and false on failure.
+    """
+    #print "copyfile(" + src + "," + dest + "," + str(newmtime) + "," + str(sstat) + ")"
+    try:
+        if not sstat:
+            sstat = os.lstat(src)
+    except Exception as e:
+        print("copyfile: Stating source file failed...", e)
+        return False
+
+    destexists = 1
+    try:
+        dstat = os.lstat(dest)
+    except:
+        dstat = os.lstat(os.path.dirname(dest))
+        destexists = 0
+
+    if destexists:
+        if stat.S_ISLNK(dstat[stat.ST_MODE]):
+            try:
+                os.unlink(dest)
+                destexists = 0
+            except Exception as e:
+                pass
+
+    if stat.S_ISLNK(sstat[stat.ST_MODE]):
+        try:
+            target = os.readlink(src)
+            if destexists and not stat.S_ISDIR(dstat[stat.ST_MODE]):
+                os.unlink(dest)
+            os.symlink(target, dest)
+            #os.lchown(dest,sstat[stat.ST_UID],sstat[stat.ST_GID])
+            return os.lstat(dest)
+        except Exception as e:
+            print("copyfile: failed to properly create symlink:", dest, "->", target, e)
+            return False
+
+    if stat.S_ISREG(sstat[stat.ST_MODE]):
+        os.chmod(src, stat.S_IRUSR) # Make sure we can read it
+        try: # For safety copy then move it over.
+            shutil.copyfile(src, dest + "#new")
+            os.rename(dest + "#new", dest)
+        except Exception as e:
+            print('copyfile: copy', src, '->', dest, 'failed.', e)
+            return False
+        finally:
+            os.chmod(src, sstat[stat.ST_MODE])
+            os.utime(src, (sstat[stat.ST_ATIME], sstat[stat.ST_MTIME]))
+
+    else:
+        #we don't yet handle special, so we need to fall back to /bin/mv
+        a = getstatusoutput("/bin/cp -f " + "'" + src + "' '" + dest + "'")
+        if a[0] != 0:
+            print("copyfile: Failed to copy special file:" + src + "' to '" + dest + "'", a)
+            return False # failure
+    try:
+        os.lchown(dest, sstat[stat.ST_UID], sstat[stat.ST_GID])
+        os.chmod(dest, stat.S_IMODE(sstat[stat.ST_MODE])) # Sticky is reset on chown
+    except Exception as e:
+        print("copyfile: Failed to chown/chmod/unlink", dest, e)
+        return False
+
+    if newmtime:
+        os.utime(dest, (newmtime, newmtime))
+    else:
+        os.utime(dest, (sstat[stat.ST_ATIME], sstat[stat.ST_MTIME]))
+        newmtime = sstat[stat.ST_MTIME]
+    return newmtime
+
+def which(path, item, direction = 0):
+    """
+    Locate a file in a PATH
+    """
+
+    paths = (path or "").split(':')
+    if direction != 0:
+        paths.reverse()
+
+    for p in paths:
+        next = os.path.join(p, item)
+        if os.path.exists(next):
+            return next
+
+    return ""
+
+def init_logger(logger, verbose, debug, debug_domains):
+    """
+    Set verbosity and debug levels in the logger
+    """
+
+    if verbose:
+        logger.set_verbose(True)
+
+    if debug:
+        logger.set_debug_level(debug)
+    else:
+        logger.set_debug_level(0)
+
+    if debug_domains:
+        logger.set_debug_domains(debug_domains)
--- a/bitbake/lib/codegen.py
+++ b/bitbake/lib/codegen.py
@@ -0,0 +1,570 @@
+# -*- coding: utf-8 -*-
+"""
+    codegen
+    ~~~~~~~
+
+    Extension to ast that allow ast -> python code generation.
+
+    :copyright: Copyright 2008 by Armin Ronacher.
+    :license: BSD.
+"""
+from ast import *
+
+BOOLOP_SYMBOLS = {
+    And:        'and',
+    Or:         'or'
+}
+
+BINOP_SYMBOLS = {
+    Add:        '+',
+    Sub:        '-',
+    Mult:       '*',
+    Div:        '/',
+    FloorDiv:   '//',
+    Mod:        '%',
+    LShift:     '<<',
+    RShift:     '>>',
+    BitOr:      '|',
+    BitAnd:     '&',
+    BitXor:     '^'
+}
+
+CMPOP_SYMBOLS = {
+    Eq:         '==',
+    Gt:         '>',
+    GtE:        '>=',
+    In:         'in',
+    Is:         'is',
+    IsNot:      'is not',
+    Lt:         '<',
+    LtE:        '<=',
+    NotEq:      '!=',
+    NotIn:      'not in'
+}
+
+UNARYOP_SYMBOLS = {
+    Invert:     '~',
+    Not:        'not',
+    UAdd:       '+',
+    USub:       '-'
+}
+
+ALL_SYMBOLS = {}
+ALL_SYMBOLS.update(BOOLOP_SYMBOLS)
+ALL_SYMBOLS.update(BINOP_SYMBOLS)
+ALL_SYMBOLS.update(CMPOP_SYMBOLS)
+ALL_SYMBOLS.update(UNARYOP_SYMBOLS)
+
+def to_source(node, indent_with=' ' * 4, add_line_information=False):
+    """This function can convert a node tree back into python sourcecode.
+    This is useful for debugging purposes, especially if you're dealing with
+    custom asts not generated by python itself.
+
+    It could be that the sourcecode is evaluable when the AST itself is not
+    compilable / evaluable.  The reason for this is that the AST contains some
+    more data than regular sourcecode does, which is dropped during
+    conversion.
+
+    Each level of indentation is replaced with `indent_with`.  Per default this
+    parameter is equal to four spaces as suggested by PEP 8, but it might be
+    adjusted to match the application's styleguide.
+
+    If `add_line_information` is set to `True` comments for the line numbers
+    of the nodes are added to the output.  This can be used to spot wrong line
+    number information of statement nodes.
+    """
+    generator = SourceGenerator(indent_with, add_line_information)
+    generator.visit(node)
+    return ''.join(generator.result)
+
+
+class SourceGenerator(NodeVisitor):
+    """This visitor is able to transform a well formed syntax tree into python
+    sourcecode.  For more details have a look at the docstring of the
+    `node_to_source` function.
+    """
+
+    def __init__(self, indent_with, add_line_information=False):
+        self.result = []
+        self.indent_with = indent_with
+        self.add_line_information = add_line_information
+        self.indentation = 0
+        self.new_lines = 0
+
+    def write(self, x):
+        if self.new_lines:
+            if self.result:
+                self.result.append('\n' * self.new_lines)
+            self.result.append(self.indent_with * self.indentation)
+            self.new_lines = 0
+        self.result.append(x)
+
+    def newline(self, node=None, extra=0):
+        self.new_lines = max(self.new_lines, 1 + extra)
+        if node is not None and self.add_line_information:
+            self.write('# line: %s' % node.lineno)
+            self.new_lines = 1
+
+    def body(self, statements):
+        self.new_line = True
+        self.indentation += 1
+        for stmt in statements:
+            self.visit(stmt)
+        self.indentation -= 1
+
+    def body_or_else(self, node):
+        self.body(node.body)
+        if node.orelse:
+            self.newline()
+            self.write('else:')
+            self.body(node.orelse)
+
+    def signature(self, node):
+        want_comma = []
+        def write_comma():
+            if want_comma:
+                self.write(', ')
+            else:
+                want_comma.append(True)
+
+        padding = [None] * (len(node.args) - len(node.defaults))
+        for arg, default in zip(node.args, padding + node.defaults):
+            write_comma()
+            self.visit(arg)
+            if default is not None:
+                self.write('=')
+                self.visit(default)
+        if node.vararg is not None:
+            write_comma()
+            self.write('*' + node.vararg)
+        if node.kwarg is not None:
+            write_comma()
+            self.write('**' + node.kwarg)
+
+    def decorators(self, node):
+        for decorator in node.decorator_list:
+            self.newline(decorator)
+            self.write('@')
+            self.visit(decorator)
+
+    # Statements
+
+    def visit_Assign(self, node):
+        self.newline(node)
+        for idx, target in enumerate(node.targets):
+            if idx:
+                self.write(', ')
+            self.visit(target)
+        self.write(' = ')
+        self.visit(node.value)
+
+    def visit_AugAssign(self, node):
+        self.newline(node)
+        self.visit(node.target)
+        self.write(BINOP_SYMBOLS[type(node.op)] + '=')
+        self.visit(node.value)
+
+    def visit_ImportFrom(self, node):
+        self.newline(node)
+        self.write('from %s%s import ' % ('.' * node.level, node.module))
+        for idx, item in enumerate(node.names):
+            if idx:
+                self.write(', ')
+            self.write(item)
+
+    def visit_Import(self, node):
+        self.newline(node)
+        for item in node.names:
+            self.write('import ')
+            self.visit(item)
+
+    def visit_Expr(self, node):
+        self.newline(node)
+        self.generic_visit(node)
+
+    def visit_FunctionDef(self, node):
+        self.newline(extra=1)
+        self.decorators(node)
+        self.newline(node)
+        self.write('def %s(' % node.name)
+        self.signature(node.args)
+        self.write('):')
+        self.body(node.body)
+
+    def visit_ClassDef(self, node):
+        have_args = []
+        def paren_or_comma():
+            if have_args:
+                self.write(', ')
+            else:
+                have_args.append(True)
+                self.write('(')
+
+        self.newline(extra=2)
+        self.decorators(node)
+        self.newline(node)
+        self.write('class %s' % node.name)
+        for base in node.bases:
+            paren_or_comma()
+            self.visit(base)
+        # XXX: the if here is used to keep this module compatible
+        #      with python 2.6.
+        if hasattr(node, 'keywords'):
+            for keyword in node.keywords:
+                paren_or_comma()
+                self.write(keyword.arg + '=')
+                self.visit(keyword.value)
+            if node.starargs is not None:
+                paren_or_comma()
+                self.write('*')
+                self.visit(node.starargs)
+            if node.kwargs is not None:
+                paren_or_comma()
+                self.write('**')
+                self.visit(node.kwargs)
+        self.write(have_args and '):' or ':')
+        self.body(node.body)
+
+    def visit_If(self, node):
+        self.newline(node)
+        self.write('if ')
+        self.visit(node.test)
+        self.write(':')
+        self.body(node.body)
+        while True:
+            else_ = node.orelse
+            if len(else_) == 1 and isinstance(else_[0], If):
+                node = else_[0]
+                self.newline()
+                self.write('elif ')
+                self.visit(node.test)
+                self.write(':')
+                self.body(node.body)
+            else:
+                self.newline()
+                self.write('else:')
+                self.body(else_)
+                break
+
+    def visit_For(self, node):
+        self.newline(node)
+        self.write('for ')
+        self.visit(node.target)
+        self.write(' in ')
+        self.visit(node.iter)
+        self.write(':')
+        self.body_or_else(node)
+
+    def visit_While(self, node):
+        self.newline(node)
+        self.write('while ')
+        self.visit(node.test)
+        self.write(':')
+        self.body_or_else(node)
+
+    def visit_With(self, node):
+        self.newline(node)
+        self.write('with ')
+        self.visit(node.context_expr)
+        if node.optional_vars is not None:
+            self.write(' as ')
+            self.visit(node.optional_vars)
+        self.write(':')
+        self.body(node.body)
+
+    def visit_Pass(self, node):
+        self.newline(node)
+        self.write('pass')
+
+    def visit_Print(self, node):
+        # XXX: python 2.6 only
+        self.newline(node)
+        self.write('print ')
+        want_comma = False
+        if node.dest is not None:
+            self.write(' >> ')
+            self.visit(node.dest)
+            want_comma = True
+        for value in node.values:
+            if want_comma:
+                self.write(', ')
+            self.visit(value)
+            want_comma = True
+        if not node.nl:
+            self.write(',')
+
+    def visit_Delete(self, node):
+        self.newline(node)
+        self.write('del ')
+        for idx, target in enumerate(node):
+            if idx:
+                self.write(', ')
+            self.visit(target)
+
+    def visit_TryExcept(self, node):
+        self.newline(node)
+        self.write('try:')
+        self.body(node.body)
+        for handler in node.handlers:
+            self.visit(handler)
+
+    def visit_TryFinally(self, node):
+        self.newline(node)
+        self.write('try:')
+        self.body(node.body)
+        self.newline(node)
+        self.write('finally:')
+        self.body(node.finalbody)
+
+    def visit_Global(self, node):
+        self.newline(node)
+        self.write('global ' + ', '.join(node.names))
+
+    def visit_Nonlocal(self, node):
+        self.newline(node)
+        self.write('nonlocal ' + ', '.join(node.names))
+
+    def visit_Return(self, node):
+        self.newline(node)
+        self.write('return ')
+        self.visit(node.value)
+
+    def visit_Break(self, node):
+        self.newline(node)
+        self.write('break')
+
+    def visit_Continue(self, node):
+        self.newline(node)
+        self.write('continue')
+
+    def visit_Raise(self, node):
+        # XXX: Python 2.6 / 3.0 compatibility
+        self.newline(node)
+        self.write('raise')
+        if hasattr(node, 'exc') and node.exc is not None:
+            self.write(' ')
+            self.visit(node.exc)
+            if node.cause is not None:
+                self.write(' from ')
+                self.visit(node.cause)
+        elif hasattr(node, 'type') and node.type is not None:
+            self.visit(node.type)
+            if node.inst is not None:
+                self.write(', ')
+                self.visit(node.inst)
+            if node.tback is not None:
+                self.write(', ')
+                self.visit(node.tback)
+
+    # Expressions
+
+    def visit_Attribute(self, node):
+        self.visit(node.value)
+        self.write('.' + node.attr)
+
+    def visit_Call(self, node):
+        want_comma = []
+        def write_comma():
+            if want_comma:
+                self.write(', ')
+            else:
+                want_comma.append(True)
+
+        self.visit(node.func)
+        self.write('(')
+        for arg in node.args:
+            write_comma()
+            self.visit(arg)
+        for keyword in node.keywords:
+            write_comma()
+            self.write(keyword.arg + '=')
+            self.visit(keyword.value)
+        if node.starargs is not None:
+            write_comma()
+            self.write('*')
+            self.visit(node.starargs)
+        if node.kwargs is not None:
+            write_comma()
+            self.write('**')
+            self.visit(node.kwargs)
+        self.write(')')
+
+    def visit_Name(self, node):
+        self.write(node.id)
+
+    def visit_Str(self, node):
+        self.write(repr(node.s))
+
+    def visit_Bytes(self, node):
+        self.write(repr(node.s))
+
+    def visit_Num(self, node):
+        self.write(repr(node.n))
+
+    def visit_Tuple(self, node):
+        self.write('(')
+        idx = -1
+        for idx, item in enumerate(node.elts):
+            if idx:
+                self.write(', ')
+            self.visit(item)
+        self.write(idx and ')' or ',)')
+
+    def sequence_visit(left, right):
+        def visit(self, node):
+            self.write(left)
+            for idx, item in enumerate(node.elts):
+                if idx:
+                    self.write(', ')
+                self.visit(item)
+            self.write(right)
+        return visit
+
+    visit_List = sequence_visit('[', ']')
+    visit_Set = sequence_visit('{', '}')
+    del sequence_visit
+
+    def visit_Dict(self, node):
+        self.write('{')
+        for idx, (key, value) in enumerate(zip(node.keys, node.values)):
+            if idx:
+                self.write(', ')
+            self.visit(key)
+            self.write(': ')
+            self.visit(value)
+        self.write('}')
+
+    def visit_BinOp(self, node):
+        self.visit(node.left)
+        self.write(' %s ' % BINOP_SYMBOLS[type(node.op)])
+        self.visit(node.right)
+
+    def visit_BoolOp(self, node):
+        self.write('(')
+        for idx, value in enumerate(node.values):
+            if idx:
+                self.write(' %s ' % BOOLOP_SYMBOLS[type(node.op)])
+            self.visit(value)
+        self.write(')')
+
+    def visit_Compare(self, node):
+        self.write('(')
+        self.write(node.left)
+        for op, right in zip(node.ops, node.comparators):
+            self.write(' %s %%' % CMPOP_SYMBOLS[type(op)])
+            self.visit(right)
+        self.write(')')
+
+    def visit_UnaryOp(self, node):
+        self.write('(')
+        op = UNARYOP_SYMBOLS[type(node.op)]
+        self.write(op)
+        if op == 'not':
+            self.write(' ')
+        self.visit(node.operand)
+        self.write(')')
+
+    def visit_Subscript(self, node):
+        self.visit(node.value)
+        self.write('[')
+        self.visit(node.slice)
+        self.write(']')
+
+    def visit_Slice(self, node):
+        if node.lower is not None:
+            self.visit(node.lower)
+        self.write(':')
+        if node.upper is not None:
+            self.visit(node.upper)
+        if node.step is not None:
+            self.write(':')
+            if not (isinstance(node.step, Name) and node.step.id == 'None'):
+                self.visit(node.step)
+
+    def visit_ExtSlice(self, node):
+        for idx, item in node.dims:
+            if idx:
+                self.write(', ')
+            self.visit(item)
+
+    def visit_Yield(self, node):
+        self.write('yield ')
+        self.visit(node.value)
+
+    def visit_Lambda(self, node):
+        self.write('lambda ')
+        self.signature(node.args)
+        self.write(': ')
+        self.visit(node.body)
+
+    def visit_Ellipsis(self, node):
+        self.write('Ellipsis')
+
+    def generator_visit(left, right):
+        def visit(self, node):
+            self.write(left)
+            self.visit(node.elt)
+            for comprehension in node.generators:
+                self.visit(comprehension)
+            self.write(right)
+        return visit
+
+    visit_ListComp = generator_visit('[', ']')
+    visit_GeneratorExp = generator_visit('(', ')')
+    visit_SetComp = generator_visit('{', '}')
+    del generator_visit
+
+    def visit_DictComp(self, node):
+        self.write('{')
+        self.visit(node.key)
+        self.write(': ')
+        self.visit(node.value)
+        for comprehension in node.generators:
+            self.visit(comprehension)
+        self.write('}')
+
+    def visit_IfExp(self, node):
+        self.visit(node.body)
+        self.write(' if ')
+        self.visit(node.test)
+        self.write(' else ')
+        self.visit(node.orelse)
+
+    def visit_Starred(self, node):
+        self.write('*')
+        self.visit(node.value)
+
+    def visit_Repr(self, node):
+        # XXX: python 2.6 only
+        self.write('`')
+        self.visit(node.value)
+        self.write('`')
+
+    # Helper Nodes
+
+    def visit_alias(self, node):
+        self.write(node.name)
+        if node.asname is not None:
+            self.write(' as ' + node.asname)
+
+    def visit_comprehension(self, node):
+        self.write(' for ')
+        self.visit(node.target)
+        self.write(' in ')
+        self.visit(node.iter)
+        if node.ifs:
+            for if_ in node.ifs:
+                self.write(' if ')
+                self.visit(if_)
+
+    def visit_excepthandler(self, node):
+        self.newline(node)
+        self.write('except')
+        if node.type is not None:
+            self.write(' ')
+            self.visit(node.type)
+            if node.name is not None:
+                self.write(' as ')
+                self.visit(node.name)
+        self.write(':')
+        self.body(node.body)
--- a/bitbake/lib/ply/init.py
+++ b/bitbake/lib/ply/init.py
@@ -0,0 +1,4 @@
+# PLY package
+# Author: David Beazley (dave@dabeaz.com)
+
+__all__ = ['lex','yacc']
--- a/bitbake/lib/ply/lex.py
+++ b/bitbake/lib/ply/lex.py
--- a/bitbake/lib/ply/yacc.py
+++ b/bitbake/lib/ply/yacc.py
--- a/meta/packages/base-files/base-files/usbd
+++ b/meta/packages/base-files/base-files/usbd
--- a/bitbake/lib/pysh/builtin.py
+++ b/bitbake/lib/pysh/builtin.py
@@ -0,0 +1,710 @@
+# builtin.py - builtins and utilities definitions for pysh.
+#
+# Copyright 2007 Patrick Mezard
+#
+# This software may be used and distributed according to the terms
+# of the GNU General Public License, incorporated herein by reference.
+
+"""Builtin and internal utilities implementations.
+
+- Beware not to use python interpreter environment as if it were the shell
+environment. For instance, commands working directory must be explicitely handled
+through env['PWD'] instead of relying on python working directory.
+"""
+import errno
+import optparse
+import os
+import re
+import subprocess
+import sys
+import time
+
+def has_subprocess_bug():
+    return getattr(subprocess, 'list2cmdline') and \
+       (    subprocess.list2cmdline(['']) == '' or \
+            subprocess.list2cmdline(['foo|bar']) == 'foo|bar')
+            
+# Detect python bug 1634343: "subprocess swallows empty arguments under win32"
+# <http://sourceforge.net/tracker/index.php?func=detail&aid=1634343&group_id=5470&atid=105470>
+# Also detect: "[ 1710802 ] subprocess must escape redirection characters under win32"
+# <http://sourceforge.net/tracker/index.php?func=detail&aid=1710802&group_id=5470&atid=105470>
+if has_subprocess_bug():
+    import subprocess_fix
+    subprocess.list2cmdline = subprocess_fix.list2cmdline
+
+from sherrors import *
+
+class NonExitingParser(optparse.OptionParser):
+    """OptionParser default behaviour upon error is to print the error message and
+    exit. Raise a utility error instead.
+    """
+    def error(self, msg):
+        raise UtilityError(msg)
+
+#-------------------------------------------------------------------------------  
+# set special builtin
+#-------------------------------------------------------------------------------  
+OPT_SET = NonExitingParser(usage="set - set or unset options and positional parameters")
+OPT_SET.add_option( '-f', action='store_true', dest='has_f', default=False,
+    help='The shell shall disable pathname expansion.')
+OPT_SET.add_option('-e', action='store_true', dest='has_e', default=False,
+    help="""When this option is on, if a simple command fails for any of the \
+    reasons listed in Consequences of Shell Errors or returns an exit status \
+    value >0, and is not part of the compound list following a while, until, \
+    or if keyword, and is not a part of an AND or OR list, and is not a \
+    pipeline preceded by the ! reserved word, then the shell shall immediately \
+    exit.""")
+OPT_SET.add_option('-x', action='store_true', dest='has_x', default=False,
+    help="""The shell shall write to standard error a trace for each command \
+    after it expands the command and before it executes it. It is unspecified \
+    whether the command that turns tracing off is traced.""")
+
+def builtin_set(name, args, interp, env, stdin, stdout, stderr, debugflags):
+    if 'debug-utility' in debugflags:
+        print interp.log(' '.join([name, str(args), interp['PWD']]) + '\n')
+
+    option, args = OPT_SET.parse_args(args)
+    env = interp.get_env()
+    
+    if option.has_f:
+        env.set_opt('-f')
+    if option.has_e:
+        env.set_opt('-e')
+    if option.has_x:
+        env.set_opt('-x')
+    return 0
+    
+#-------------------------------------------------------------------------------  
+# shift special builtin
+#-------------------------------------------------------------------------------  
+def builtin_shift(name, args, interp, env, stdin, stdout, stderr, debugflags):
+    if 'debug-utility' in debugflags:
+        print interp.log(' '.join([name, str(args), interp['PWD']]) + '\n')
+        
+    params = interp.get_env().get_positional_args()
+    if args:
+        try:
+            n = int(args[0])
+            if n > len(params):
+                raise ValueError()
+        except ValueError:
+            return 1
+    else:
+        n = 1
+        
+    params[:n] = []
+    interp.get_env().set_positional_args(params)
+    return 0
+    
+#-------------------------------------------------------------------------------  
+# export special builtin
+#-------------------------------------------------------------------------------  
+OPT_EXPORT = NonExitingParser(usage="set - set or unset options and positional parameters")
+OPT_EXPORT.add_option('-p', action='store_true', dest='has_p', default=False)
+
+def builtin_export(name, args, interp, env, stdin, stdout, stderr, debugflags):
+    if 'debug-utility' in debugflags:
+        print interp.log(' '.join([name, str(args), interp['PWD']]) + '\n')
+        
+    option, args = OPT_EXPORT.parse_args(args)
+    if option.has_p:
+        raise NotImplementedError()
+    
+    for arg in args:
+        try:
+            name, value = arg.split('=', 1)
+        except ValueError:
+            name, value = arg, None
+        env = interp.get_env().export(name, value)
+    
+    return 0
+    
+#-------------------------------------------------------------------------------  
+# return special builtin
+#-------------------------------------------------------------------------------  
+def builtin_return(name, args, interp, env, stdin, stdout, stderr, debugflags):
+    if 'debug-utility' in debugflags:
+        print interp.log(' '.join([name, str(args), interp['PWD']]) + '\n')
+    res = 0
+    if args:
+        try:
+            res = int(args[0])
+        except ValueError:
+            res = 0
+        if not 0<=res<=255:
+            res = 0
+            
+    # BUG: should be last executed command exit code        
+    raise ReturnSignal(res)
+
+#-------------------------------------------------------------------------------  
+# trap special builtin
+#-------------------------------------------------------------------------------  
+def builtin_trap(name, args, interp, env, stdin, stdout, stderr, debugflags):
+    if 'debug-utility' in debugflags:
+        print interp.log(' '.join([name, str(args), interp['PWD']]) + '\n')
+    if len(args) < 2:
+        stderr.write('trap: usage: trap [[arg] signal_spec ...]\n')
+        return 2
+
+    action = args[0]
+    for sig in args[1:]:
+        try:
+            env.traps[sig] = action
+        except Exception, e:
+            stderr.write('trap: %s\n' % str(e))
+    return 0
+
+#-------------------------------------------------------------------------------  
+# unset special builtin
+#-------------------------------------------------------------------------------
+OPT_UNSET = NonExitingParser("unset - unset values and attributes of variables and functions")
+OPT_UNSET.add_option( '-f', action='store_true', dest='has_f', default=False)
+OPT_UNSET.add_option( '-v', action='store_true', dest='has_v', default=False)
+
+def builtin_unset(name, args, interp, env, stdin, stdout, stderr, debugflags):
+    if 'debug-utility' in debugflags:
+        print interp.log(' '.join([name, str(args), interp['PWD']]) + '\n')
+        
+    option, args = OPT_UNSET.parse_args(args)
+    
+    status = 0
+    env = interp.get_env()
+    for arg in args:    
+        try:
+            if option.has_f:
+                env.remove_function(arg)
+            else:
+                del env[arg]
+        except KeyError:
+            pass
+        except VarAssignmentError:
+            status = 1
+            
+    return status
+
+#-------------------------------------------------------------------------------  
+# wait special builtin
+#-------------------------------------------------------------------------------  
+def builtin_wait(name, args, interp, env, stdin, stdout, stderr, debugflags):
+    if 'debug-utility' in debugflags:
+        print interp.log(' '.join([name, str(args), interp['PWD']]) + '\n')
+
+    return interp.wait([int(arg) for arg in args])
+
+#-------------------------------------------------------------------------------  
+# cat utility
+#-------------------------------------------------------------------------------
+def utility_cat(name, args, interp, env, stdin, stdout, stderr, debugflags):
+    if 'debug-utility' in debugflags:
+        print interp.log(' '.join([name, str(args), interp['PWD']]) + '\n')
+
+    if not args:
+        args = ['-']
+
+    status = 0
+    for arg in args:
+        if arg == '-':
+            data = stdin.read()
+        else:
+            path = os.path.join(env['PWD'], arg)
+            try:
+                f = file(path, 'rb')
+                try:
+                    data = f.read()
+                finally:
+                    f.close()
+            except IOError, e:
+                if e.errno != errno.ENOENT:
+                    raise
+                status = 1
+                continue
+        stdout.write(data)
+        stdout.flush()
+    return status
+    
+#-------------------------------------------------------------------------------  
+# cd utility
+#-------------------------------------------------------------------------------  
+OPT_CD = NonExitingParser("cd - change the working directory")
+
+def utility_cd(name, args, interp, env, stdin, stdout, stderr, debugflags):
+    if 'debug-utility' in debugflags:
+        print interp.log(' '.join([name, str(args), interp['PWD']]) + '\n')
+
+    option, args = OPT_CD.parse_args(args)
+    env = interp.get_env()
+    
+    directory = None
+    printdir = False
+    if not args:
+        home = env.get('HOME')
+        if home:
+            # Unspecified, do nothing
+            return 0
+        else:
+            directory = home
+    elif len(args)==1:
+        directory = args[0]
+        if directory=='-':
+            if 'OLDPWD' not in env:
+                raise UtilityError("OLDPWD not set")
+            printdir = True
+            directory = env['OLDPWD']
+    else:
+        raise UtilityError("too many arguments")
+            
+    curpath = None
+    # Absolute directories will be handled correctly by the os.path.join call.
+    if not directory.startswith('.') and not directory.startswith('..'):
+        cdpaths = env.get('CDPATH', '.').split(';')
+        for cdpath in cdpaths:
+            p = os.path.join(cdpath, directory)
+            if os.path.isdir(p):
+                curpath = p
+                break
+    
+    if curpath is None:
+        curpath = directory
+    curpath = os.path.join(env['PWD'], directory)
+
+    env['OLDPWD'] = env['PWD']
+    env['PWD'] = curpath
+    if printdir:
+        stdout.write('%s\n' % curpath)
+    return 0
+
+#-------------------------------------------------------------------------------  
+# colon utility
+#-------------------------------------------------------------------------------  
+def utility_colon(name, args, interp, env, stdin, stdout, stderr, debugflags):
+    if 'debug-utility' in debugflags:
+        print interp.log(' '.join([name, str(args), interp['PWD']]) + '\n')
+    return 0
+    
+#-------------------------------------------------------------------------------  
+# echo utility
+#-------------------------------------------------------------------------------  
+def utility_echo(name, args, interp, env, stdin, stdout, stderr, debugflags):
+    if 'debug-utility' in debugflags:
+        print interp.log(' '.join([name, str(args), interp['PWD']]) + '\n')
+        
+    # Echo only takes arguments, no options. Use printf if you need fancy stuff.
+    output = ' '.join(args) + '\n'
+    stdout.write(output)
+    stdout.flush()
+    return 0
+    
+#-------------------------------------------------------------------------------  
+# egrep utility
+#-------------------------------------------------------------------------------
+# egrep is usually a shell script.
+# Unfortunately, pysh does not support shell scripts *with arguments* right now,
+# so the redirection is implemented here, assuming grep is available.
+def utility_egrep(name, args, interp, env, stdin, stdout, stderr, debugflags):
+    if 'debug-utility' in debugflags:
+        print interp.log(' '.join([name, str(args), interp['PWD']]) + '\n')
+        
+    return run_command('grep', ['-E'] + args, interp, env, stdin, stdout, 
+        stderr, debugflags)
+    
+#-------------------------------------------------------------------------------  
+# env utility
+#-------------------------------------------------------------------------------  
+def utility_env(name, args, interp, env, stdin, stdout, stderr, debugflags):
+    if 'debug-utility' in debugflags:
+        print interp.log(' '.join([name, str(args), interp['PWD']]) + '\n')
+    
+    if args and args[0]=='-i':
+        raise NotImplementedError('env: -i option is not implemented')
+    
+    i = 0
+    for arg in args:
+        if '=' not in arg:
+            break
+        # Update the current environment
+        name, value = arg.split('=', 1)
+        env[name] = value
+        i += 1
+        
+    if args[i:]:
+        # Find then execute the specified interpreter
+        utility = env.find_in_path(args[i])
+        if not utility:
+            return 127
+        args[i:i+1] = utility
+        name = args[i]
+        args = args[i+1:]
+        try:
+            return run_command(name, args, interp, env, stdin, stdout, stderr, 
+                debugflags)
+        except UtilityError:
+            stderr.write('env: failed to execute %s' % ' '.join([name]+args))
+            return 126            
+    else:
+        for pair in env.get_variables().iteritems():
+            stdout.write('%s=%s\n' % pair)
+    return 0
+    
+#-------------------------------------------------------------------------------  
+# exit utility
+#-------------------------------------------------------------------------------
+def utility_exit(name, args, interp, env, stdin, stdout, stderr, debugflags):
+    if 'debug-utility' in debugflags:
+        print interp.log(' '.join([name, str(args), interp['PWD']]) + '\n')
+        
+    res = None
+    if args:
+        try:
+            res = int(args[0])
+        except ValueError:
+            res = None
+        if not 0<=res<=255:
+            res = None
+            
+    if res is None:
+        # BUG: should be last executed command exit code
+        res = 0
+        
+    raise ExitSignal(res)
+
+#-------------------------------------------------------------------------------  
+# fgrep utility
+#-------------------------------------------------------------------------------
+# see egrep
+def utility_fgrep(name, args, interp, env, stdin, stdout, stderr, debugflags):
+    if 'debug-utility' in debugflags:
+        print interp.log(' '.join([name, str(args), interp['PWD']]) + '\n')
+        
+    return run_command('grep', ['-F'] + args, interp, env, stdin, stdout, 
+        stderr, debugflags)
+
+#-------------------------------------------------------------------------------  
+# gunzip utility
+#-------------------------------------------------------------------------------
+# see egrep
+def utility_gunzip(name, args, interp, env, stdin, stdout, stderr, debugflags):
+    if 'debug-utility' in debugflags:
+        print interp.log(' '.join([name, str(args), interp['PWD']]) + '\n')
+        
+    return run_command('gzip', ['-d'] + args, interp, env, stdin, stdout, 
+        stderr, debugflags)
+    
+#-------------------------------------------------------------------------------  
+# kill utility
+#-------------------------------------------------------------------------------
+def utility_kill(name, args, interp, env, stdin, stdout, stderr, debugflags):
+    if 'debug-utility' in debugflags:
+        print interp.log(' '.join([name, str(args), interp['PWD']]) + '\n')
+        
+    for arg in args:
+        pid = int(arg)
+        status = subprocess.call(['pskill', '/T', str(pid)],
+                                shell=True,
+                                stdout=subprocess.PIPE,
+                                stderr=subprocess.PIPE)
+        # pskill is asynchronous, hence the stupid polling loop
+        while 1:
+            p = subprocess.Popen(['pslist', str(pid)],
+                                shell=True,
+                                stdout=subprocess.PIPE,
+                                stderr=subprocess.STDOUT)
+            output = p.communicate()[0]
+            if ('process %d was not' % pid) in output:
+                break
+            time.sleep(1)
+    return status
+    
+#-------------------------------------------------------------------------------  
+# mkdir utility
+#-------------------------------------------------------------------------------
+OPT_MKDIR = NonExitingParser("mkdir - make directories.")
+OPT_MKDIR.add_option('-p', action='store_true', dest='has_p', default=False)
+
+def utility_mkdir(name, args, interp, env, stdin, stdout, stderr, debugflags):
+    if 'debug-utility' in debugflags:
+        print interp.log(' '.join([name, str(args), interp['PWD']]) + '\n')
+        
+    # TODO: implement umask
+    # TODO: implement proper utility error report
+    option, args = OPT_MKDIR.parse_args(args)
+    for arg in args:
+        path = os.path.join(env['PWD'], arg)
+        if option.has_p:
+            try:
+                os.makedirs(path)
+            except IOError, e:
+                if e.errno != errno.EEXIST:
+                    raise
+        else:               
+            os.mkdir(path)
+    return 0
+
+#-------------------------------------------------------------------------------  
+# netstat utility
+#-------------------------------------------------------------------------------
+def utility_netstat(name, args, interp, env, stdin, stdout, stderr, debugflags):
+    # Do you really expect me to implement netstat ?
+    # This empty form is enough for Mercurial tests since it's
+    # supposed to generate nothing upon success. Faking this test
+    # is not a big deal either.
+    if 'debug-utility' in debugflags:
+        print interp.log(' '.join([name, str(args), interp['PWD']]) + '\n')
+    return 0
+    
+#-------------------------------------------------------------------------------  
+# pwd utility
+#-------------------------------------------------------------------------------  
+OPT_PWD = NonExitingParser("pwd - return working directory name")
+OPT_PWD.add_option('-L', action='store_true', dest='has_L', default=True,
+    help="""If the PWD environment variable contains an absolute pathname of \
+    the current directory that does not contain the filenames dot or dot-dot, \
+    pwd shall write this pathname to standard output. Otherwise, the -L option \
+    shall behave as the -P option.""")
+OPT_PWD.add_option('-P', action='store_true', dest='has_L', default=False,
+    help="""The absolute pathname written shall not contain filenames that, in \
+    the context of the pathname, refer to files of type symbolic link.""")
+
+def utility_pwd(name, args, interp, env, stdin, stdout, stderr, debugflags):
+    if 'debug-utility' in debugflags:
+        print interp.log(' '.join([name, str(args), interp['PWD']]) + '\n')
+
+    option, args = OPT_PWD.parse_args(args)        
+    stdout.write('%s\n' % env['PWD'])
+    return 0
+    
+#-------------------------------------------------------------------------------  
+# printf utility
+#-------------------------------------------------------------------------------
+RE_UNESCAPE = re.compile(r'(\\x[a-zA-Z0-9]{2}|\\[0-7]{1,3}|\\.)')
+
+def utility_printf(name, args, interp, env, stdin, stdout, stderr, debugflags):
+    if 'debug-utility' in debugflags:
+        print interp.log(' '.join([name, str(args), interp['PWD']]) + '\n')
+        
+    def replace(m):
+        assert m.group()
+        g = m.group()[1:]
+        if g.startswith('x'):
+            return chr(int(g[1:], 16))
+        if len(g) <= 3 and len([c for c in g if c in '01234567']) == len(g):
+            # Yay, an octal number
+            return chr(int(g, 8))
+        return {
+            'a': '\a',
+            'b': '\b',
+            'f': '\f',
+            'n': '\n',
+            'r': '\r',
+            't': '\t',
+            'v': '\v',
+            '\\': '\\',
+        }.get(g)
+        
+    # Convert escape sequences
+    format = re.sub(RE_UNESCAPE, replace, args[0])
+    stdout.write(format % tuple(args[1:]))
+    return 0
+    
+#-------------------------------------------------------------------------------  
+# true utility
+#-------------------------------------------------------------------------------
+def utility_true(name, args, interp, env, stdin, stdout, stderr, debugflags):
+    if 'debug-utility' in debugflags:
+        print interp.log(' '.join([name, str(args), interp['PWD']]) + '\n')
+    return 0
+
+#-------------------------------------------------------------------------------  
+# sed utility
+#-------------------------------------------------------------------------------
+RE_SED = re.compile(r'^s(.).*\1[a-zA-Z]*$')
+
+# cygwin sed fails with some expressions when they do not end with a single space.
+# see unit tests for details. Interestingly, the same expressions works perfectly
+# in cygwin shell.
+def utility_sed(name, args, interp, env, stdin, stdout, stderr, debugflags):
+    if 'debug-utility' in debugflags:
+        print interp.log(' '.join([name, str(args), interp['PWD']]) + '\n')
+        
+    # Scan pattern arguments and append a space if necessary
+    for i in xrange(len(args)):
+        if not RE_SED.search(args[i]):
+            continue
+        args[i] = args[i] + ' '
+
+    return run_command(name, args, interp, env, stdin, stdout, 
+        stderr, debugflags)
+
+#-------------------------------------------------------------------------------  
+# sleep utility
+#-------------------------------------------------------------------------------
+def utility_sleep(name, args, interp, env, stdin, stdout, stderr, debugflags):
+    if 'debug-utility' in debugflags:
+        print interp.log(' '.join([name, str(args), interp['PWD']]) + '\n')
+    time.sleep(int(args[0]))
+    return 0
+    
+#-------------------------------------------------------------------------------  
+# sort utility
+#-------------------------------------------------------------------------------
+OPT_SORT = NonExitingParser("sort - sort, merge, or sequence check text files")
+
+def utility_sort(name, args, interp, env, stdin, stdout, stderr, debugflags):
+
+    def sort(path):
+        if path == '-':
+            lines = stdin.readlines()
+        else:
+            try:
+                f = file(path)
+                try:
+                    lines = f.readlines()
+                finally:
+                    f.close()
+            except IOError, e:
+                stderr.write(str(e) + '\n')
+                return 1
+        
+        if lines and lines[-1][-1]!='\n':
+            lines[-1] = lines[-1] + '\n'
+        return lines
+    
+    if 'debug-utility' in debugflags:
+        print interp.log(' '.join([name, str(args), interp['PWD']]) + '\n')
+        
+    option, args = OPT_SORT.parse_args(args)
+    alllines = []
+    
+    if len(args)<=0:
+        args += ['-']
+        
+    # Load all files lines
+    curdir = os.getcwd()
+    try:
+        os.chdir(env['PWD'])
+        for path in args:
+            alllines += sort(path)
+    finally:
+        os.chdir(curdir)
+            
+    alllines.sort()
+    for line in alllines:
+        stdout.write(line)
+    return 0
+    
+#-------------------------------------------------------------------------------
+# hg utility
+#-------------------------------------------------------------------------------
+
+hgcommands = [
+    'add',
+    'addremove',
+    'commit', 'ci',
+    'debugrename',
+    'debugwalk',
+    'falabala', # Dummy command used in a mercurial test
+    'incoming',
+    'locate',
+    'pull',
+    'push',
+    'qinit',
+    'remove', 'rm',
+    'rename', 'mv',
+    'revert',    
+    'showconfig',
+    'status', 'st',
+    'strip',
+    ]
+
+def rewriteslashes(name, args):
+    # Several hg commands output file paths, rewrite the separators
+    if len(args) > 1 and name.lower().endswith('python') \
+       and args[0].endswith('hg'):
+        for cmd in hgcommands:
+            if cmd in args[1:]:
+                return True
+            
+    # svn output contains many paths with OS specific separators.
+    # Normalize these to unix paths.
+    base = os.path.basename(name)
+    if base.startswith('svn'):
+        return True
+    
+    return False
+
+def rewritehg(output):
+    if not output:
+        return output
+    # Rewrite os specific messages
+    output = output.replace(': The system cannot find the file specified',
+                            ': No such file or directory')
+    output = re.sub(': Access is denied.*$', ': Permission denied', output)
+    output = output.replace(': No connection could be made because the target machine actively refused it',
+                            ': Connection refused')
+    return output
+                            
+
+def run_command(name, args, interp, env, stdin, stdout,
+                stderr, debugflags):
+    # Execute the command
+    if 'debug-utility' in debugflags:
+        print interp.log(' '.join([name, str(args), interp['PWD']]) + '\n')
+
+    hgbin = interp.options().hgbinary
+    ishg = hgbin and ('hg' in name or args and 'hg' in args[0])
+    unixoutput = 'cygwin' in name or ishg
+    
+    exec_env = env.get_variables()        
+    try:
+        # BUG: comparing file descriptor is clearly not a reliable way to tell
+        # whether they point on the same underlying object. But in pysh limited
+        # scope this is usually right, we do not expect complicated redirections
+        # besides usual 2>&1.
+        # Still there is one case we have but cannot deal with is when stdout
+        # and stderr are redirected *by pysh caller*. This the reason for the
+        # --redirect pysh() option.
+        # Now, we want to know they are the same because we sometimes need to 
+        # transform the command output, mostly remove CR-LF to ensure that
+        # command output is unix-like. Cygwin utilies are a special case because
+        # they explicitely set their output streams to binary mode, so we have
+        # nothing to do. For all others commands, we have to guess whether they
+        # are sending text data, in which case the transformation must be done.
+        # Again, the NUL character test is unreliable but should be enough for
+        # hg tests.
+        redirected = stdout.fileno()==stderr.fileno()
+        if not redirected:
+            p = subprocess.Popen([name] + args, cwd=env['PWD'], env=exec_env, 
+                    stdin=stdin, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+        else:
+            p = subprocess.Popen([name] + args, cwd=env['PWD'], env=exec_env, 
+                    stdin=stdin, stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
+        out, err = p.communicate()
+    except WindowsError, e:
+        raise UtilityError(str(e))
+
+    if not unixoutput:
+        def encode(s):
+            if '\0' in s:
+                return s
+            return s.replace('\r\n', '\n')
+    else:
+        encode = lambda s: s
+
+    if rewriteslashes(name, args):
+        encode1_ = encode
+        def encode(s):
+            s = encode1_(s)
+            s = s.replace('\\\\', '\\')
+            s = s.replace('\\', '/')
+            return s
+
+    if ishg:
+        encode2_ = encode
+        def encode(s):
+            return rewritehg(encode2_(s))
+    
+    stdout.write(encode(out))
+    if not redirected:
+        stderr.write(encode(err))
+    return p.returncode
+            
--- a/bitbake/lib/pysh/interp.py
+++ b/bitbake/lib/pysh/interp.py
--- a/bitbake/lib/pysh/lsprof.py
+++ b/bitbake/lib/pysh/lsprof.py
@@ -0,0 +1,116 @@
+#! /usr/bin/env python
+
+import sys
+from _lsprof import Profiler, profiler_entry
+
+__all__ = ['profile', 'Stats']
+
+def profile(f, *args, **kwds):
+    """XXX docstring"""
+    p = Profiler()
+    p.enable(subcalls=True, builtins=True)
+    try:
+        f(*args, **kwds)
+    finally:
+        p.disable()
+    return Stats(p.getstats())
+
+
+class Stats(object):
+    """XXX docstring"""
+
+    def __init__(self, data):
+        self.data = data
+
+    def sort(self, crit="inlinetime"):
+        """XXX docstring"""
+        if crit not in profiler_entry.__dict__:
+            raise ValueError("Can't sort by %s" % crit)
+        self.data.sort(lambda b, a: cmp(getattr(a, crit),
+                                        getattr(b, crit)))
+        for e in self.data:
+            if e.calls:
+                e.calls.sort(lambda b, a: cmp(getattr(a, crit),
+                                              getattr(b, crit)))
+
+    def pprint(self, top=None, file=None, limit=None, climit=None):
+        """XXX docstring"""
+        if file is None:
+            file = sys.stdout
+        d = self.data
+        if top is not None:
+            d = d[:top]
+        cols = "% 12s %12s %11.4f %11.4f   %s\n"
+        hcols = "% 12s %12s %12s %12s %s\n"
+        cols2 = "+%12s %12s %11.4f %11.4f +  %s\n"
+        file.write(hcols % ("CallCount", "Recursive", "Total(ms)",
+                            "Inline(ms)", "module:lineno(function)"))
+        count = 0
+        for e in d:
+            file.write(cols % (e.callcount, e.reccallcount, e.totaltime,
+                               e.inlinetime, label(e.code)))
+            count += 1
+            if limit is not None and count == limit:
+                return
+            ccount = 0
+            if e.calls:
+                for se in e.calls:
+                    file.write(cols % ("+%s" % se.callcount, se.reccallcount,
+                                       se.totaltime, se.inlinetime,
+                                       "+%s" % label(se.code)))
+                    count += 1
+                    ccount += 1
+                    if limit is not None and count == limit:
+                        return
+                    if climit is not None and ccount == climit:
+                        break
+
+    def freeze(self):
+        """Replace all references to code objects with string
+        descriptions; this makes it possible to pickle the instance."""
+
+        # this code is probably rather ickier than it needs to be!
+        for i in range(len(self.data)):
+            e = self.data[i]
+            if not isinstance(e.code, str):
+                self.data[i] = type(e)((label(e.code),) + e[1:])
+            if e.calls:
+                for j in range(len(e.calls)):
+                    se = e.calls[j]
+                    if not isinstance(se.code, str):
+                        e.calls[j] = type(se)((label(se.code),) + se[1:])
+
+_fn2mod = {}
+
+def label(code):
+    if isinstance(code, str):
+        return code
+    try:
+        mname = _fn2mod[code.co_filename]
+    except KeyError:
+        for k, v in sys.modules.items():
+            if v is None:
+                continue
+            if not hasattr(v, '__file__'):
+                continue
+            if not isinstance(v.__file__, str):
+                continue
+            if v.__file__.startswith(code.co_filename):
+                mname = _fn2mod[code.co_filename] = k
+                break
+        else:
+            mname = _fn2mod[code.co_filename] = '<%s>'%code.co_filename
+
+    return '%s:%d(%s)' % (mname, code.co_firstlineno, code.co_name)
+
+
+if __name__ == '__main__':
+    import os
+    sys.argv = sys.argv[1:]
+    if not sys.argv:
+        print >> sys.stderr, "usage: lsprof.py <script> <arguments...>"
+        sys.exit(2)
+    sys.path.insert(0, os.path.abspath(os.path.dirname(sys.argv[0])))
+    stats = profile(execfile, sys.argv[0], globals(), locals())
+    stats.sort()
+    stats.pprint()
--- a/bitbake/lib/pysh/pysh.py
+++ b/bitbake/lib/pysh/pysh.py
@@ -0,0 +1,167 @@
+# pysh.py - command processing for pysh.
+#
+# Copyright 2007 Patrick Mezard
+#
+# This software may be used and distributed according to the terms
+# of the GNU General Public License, incorporated herein by reference.
+
+import optparse
+import os
+import sys
+
+import interp
+
+SH_OPT = optparse.OptionParser(prog='pysh', usage="%prog [OPTIONS]", version='0.1')
+SH_OPT.add_option('-c', action='store_true', dest='command_string', default=None, 
+    help='A string that shall be interpreted by the shell as one or more commands')
+SH_OPT.add_option('--redirect-to', dest='redirect_to', default=None, 
+    help='Redirect script commands stdout and stderr to the specified file')
+# See utility_command in builtin.py about the reason for this flag.
+SH_OPT.add_option('--redirected', dest='redirected', action='store_true', default=False, 
+    help='Tell the interpreter that stdout and stderr are actually the same objects, which is really stdout')
+SH_OPT.add_option('--debug-parsing', action='store_true', dest='debug_parsing', default=False, 
+    help='Trace PLY execution')
+SH_OPT.add_option('--debug-tree', action='store_true', dest='debug_tree', default=False, 
+    help='Display the generated syntax tree.')
+SH_OPT.add_option('--debug-cmd', action='store_true', dest='debug_cmd', default=False, 
+    help='Trace command execution before parameters expansion and exit status.')
+SH_OPT.add_option('--debug-utility', action='store_true', dest='debug_utility', default=False, 
+    help='Trace utility calls, after parameters expansions')
+SH_OPT.add_option('--ast', action='store_true', dest='ast', default=False,
+    help='Encoded commands to execute in a subprocess')
+SH_OPT.add_option('--profile', action='store_true', default=False,
+    help='Profile pysh run')
+    
+    
+def split_args(args):
+    # Separate shell arguments from command ones
+    # Just stop at the first argument not starting with a dash. I know, this is completely broken,
+    # it ignores files starting with a dash or may take option values for command file. This is not
+    # supposed to happen for now
+    command_index = len(args)
+    for i,arg in enumerate(args):
+        if not arg.startswith('-'):
+            command_index = i
+            break
+            
+    return args[:command_index], args[command_index:]
+
+
+def fixenv(env):
+    path = env.get('PATH')
+    if path is not None:
+        parts = path.split(os.pathsep)
+        # Remove Windows utilities from PATH, they are useless at best and
+        # some of them (find) may be confused with other utilities.
+        parts = [p for p in parts if 'system32' not in p.lower()]
+        env['PATH'] = os.pathsep.join(parts)
+    if env.get('HOME') is None:
+        # Several utilities, including cvsps, cannot work without
+        # a defined HOME directory.
+        env['HOME'] = os.path.expanduser('~')
+    return env
+
+def _sh(cwd, shargs, cmdargs, options, debugflags=None, env=None):
+    if os.environ.get('PYSH_TEXT') != '1':
+        import msvcrt
+        for fp in (sys.stdin, sys.stdout, sys.stderr):
+            msvcrt.setmode(fp.fileno(), os.O_BINARY)
+
+    hgbin = os.environ.get('PYSH_HGTEXT') != '1'
+    
+    if debugflags is None:
+        debugflags = []
+        if options.debug_parsing:    debugflags.append('debug-parsing')
+        if options.debug_utility:    debugflags.append('debug-utility')
+        if options.debug_cmd:        debugflags.append('debug-cmd')
+        if options.debug_tree:       debugflags.append('debug-tree')
+    
+    if env is None:
+        env = fixenv(dict(os.environ))
+    if cwd is None:
+        cwd = os.getcwd()
+
+    if not cmdargs:
+        # Nothing to do
+        return 0
+
+    ast = None
+    command_file = None
+    if options.command_string:
+        input = cmdargs[0]
+        if not options.ast:
+            input += '\n'
+        else:
+            args, input = interp.decodeargs(input), None
+            env, ast = args
+            cwd = env.get('PWD', cwd)
+    else:
+        command_file = cmdargs[0]
+        arguments = cmdargs[1:]
+
+        prefix = interp.resolve_shebang(command_file, ignoreshell=True)
+        if prefix:
+            input = ' '.join(prefix + [command_file] + arguments)
+        else:
+            # Read commands from file
+            f = file(command_file)
+            try:
+                # Trailing newline to help the parser
+                input = f.read() + '\n'
+            finally:
+                f.close()
+    
+    redirect = None
+    try:
+        if options.redirected:
+            stdout = sys.stdout
+            stderr = stdout
+        elif options.redirect_to:
+            redirect = open(options.redirect_to, 'wb')
+            stdout = redirect
+            stderr = redirect
+        else:
+            stdout = sys.stdout
+            stderr = sys.stderr
+            
+        # TODO: set arguments to environment variables
+        opts = interp.Options()
+        opts.hgbinary = hgbin
+        ip = interp.Interpreter(cwd, debugflags, stdout=stdout, stderr=stderr,
+                                opts=opts)
+        try:
+            # Export given environment in shell object
+            for k,v in env.iteritems():
+                ip.get_env().export(k,v)
+            return ip.execute_script(input, ast, scriptpath=command_file)
+        finally:
+            ip.close()
+    finally:
+        if redirect is not None:
+            redirect.close()
+
+def sh(cwd=None, args=None, debugflags=None, env=None):
+    if args is None:
+        args = sys.argv[1:]
+    shargs, cmdargs = split_args(args)
+    options, shargs = SH_OPT.parse_args(shargs)
+
+    if options.profile:
+        import lsprof
+        p = lsprof.Profiler()
+        p.enable(subcalls=True)
+        try:
+            return _sh(cwd, shargs, cmdargs, options, debugflags, env)
+        finally:
+            p.disable()
+            stats = lsprof.Stats(p.getstats())
+            stats.sort()
+            stats.pprint(top=10, file=sys.stderr, climit=5)
+    else:
+        return _sh(cwd, shargs, cmdargs, options, debugflags, env)
+            
+def main():
+    sys.exit(sh())
+
+if __name__=='__main__':
+    main()
--- a/bitbake/lib/pysh/pyshlex.py
+++ b/bitbake/lib/pysh/pyshlex.py
@@ -0,0 +1,888 @@
+# pyshlex.py - PLY compatible lexer for pysh.
+#
+# Copyright 2007 Patrick Mezard
+#
+# This software may be used and distributed according to the terms
+# of the GNU General Public License, incorporated herein by reference.
+
+# TODO:
+# - review all "char in 'abc'" snippets: the empty string can be matched
+# - test line continuations within quoted/expansion strings
+# - eof is buggy wrt sublexers
+# - the lexer cannot really work in pull mode as it would be required to run
+# PLY in pull mode. It was designed to work incrementally and it would not be
+# that hard to enable pull mode.
+import re
+try:
+    s = set()
+    del s
+except NameError:
+    from Set import Set as set
+
+from ply import lex
+from sherrors import *
+
+class NeedMore(Exception):
+    pass
+
+def is_blank(c):
+    return c in (' ', '\t')
+    
+_RE_DIGITS = re.compile(r'^\d+$')
+
+def are_digits(s):
+    return _RE_DIGITS.search(s) is not None
+
+_OPERATORS = dict([
+    ('&&', 'AND_IF'),
+    ('||', 'OR_IF'),
+    (';;', 'DSEMI'),
+    ('<<', 'DLESS'),
+    ('>>', 'DGREAT'),
+    ('<&', 'LESSAND'),
+    ('>&', 'GREATAND'),
+    ('<>', 'LESSGREAT'),
+    ('<<-', 'DLESSDASH'),
+    ('>|', 'CLOBBER'),
+    ('&', 'AMP'),
+    (';', 'COMMA'),
+    ('<', 'LESS'),
+    ('>', 'GREATER'),
+    ('(', 'LPARENS'),
+    (')', 'RPARENS'),
+])
+
+#Make a function to silence pychecker "Local variable shadows global"
+def make_partial_ops():
+    partials = {}
+    for k in _OPERATORS:
+        for i in range(1, len(k)+1):
+            partials[k[:i]] = None
+    return partials  
+
+_PARTIAL_OPERATORS = make_partial_ops()    
+        
+def is_partial_op(s):
+    """Return True if s matches a non-empty subpart of an operator starting
+    at its first character.
+    """
+    return s in _PARTIAL_OPERATORS
+    
+def is_op(s):
+    """If s matches an operator, returns the operator identifier. Return None
+    otherwise.
+    """
+    return _OPERATORS.get(s)
+
+_RESERVEDS = dict([
+    ('if', 'If'),
+    ('then', 'Then'),
+    ('else', 'Else'),
+    ('elif', 'Elif'),
+    ('fi', 'Fi'),
+    ('do', 'Do'),
+    ('done', 'Done'),
+    ('case', 'Case'),
+    ('esac', 'Esac'),
+    ('while', 'While'),
+    ('until', 'Until'),
+    ('for', 'For'),
+    ('{', 'Lbrace'),
+    ('}', 'Rbrace'),
+    ('!', 'Bang'),
+    ('in', 'In'),
+    ('|', 'PIPE'),
+])
+    
+def get_reserved(s):
+    return _RESERVEDS.get(s)
+    
+_RE_NAME = re.compile(r'^[0-9a-zA-Z_]+$')
+
+def is_name(s):
+    return _RE_NAME.search(s) is not None
+
+def find_chars(seq, chars):
+    for i,v in enumerate(seq):
+        if v in chars:
+            return i,v
+    return -1, None
+
+class WordLexer:
+    """WordLexer parse quoted or expansion expressions and return an expression
+    tree. The input string can be any well formed sequence beginning with quoting
+    or expansion character. Embedded expressions are handled recursively. The
+    resulting tree is made of lists and strings. Lists represent quoted or
+    expansion expressions. Each list first element is the opening separator,
+    the last one the closing separator. In-between can be any number of strings
+    or lists for sub-expressions. Non quoted/expansion expression can written as
+    strings or as lists with empty strings as starting and ending delimiters.
+    """
+
+    NAME_CHARSET = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_'
+    NAME_CHARSET = dict(zip(NAME_CHARSET, NAME_CHARSET))
+    
+    SPECIAL_CHARSET = '@*#?-$!0'
+    
+    #Characters which can be escaped depends on the current delimiters
+    ESCAPABLE = {
+        '`': set(['$', '\\', '`']),
+        '"': set(['$', '\\', '`', '"']),
+        "'": set(),
+    }
+        
+    def __init__(self, heredoc = False):
+        # _buffer is the unprocessed input characters buffer
+        self._buffer = []
+        # _stack is empty or contains a quoted list being processed
+        # (this is the DFS path to the quoted expression being evaluated).
+        self._stack = []
+        self._escapable = None
+        # True when parsing unquoted here documents
+        self._heredoc = heredoc
+        
+    def add(self, data, eof=False):
+        """Feed the lexer with more data. If the quoted expression can be
+        delimited, return a tuple (expr, remaining) containing the expression
+        tree and the unconsumed data.
+        Otherwise, raise NeedMore.
+        """
+        self._buffer += list(data)
+        self._parse(eof)
+        
+        result = self._stack[0]
+        remaining = ''.join(self._buffer)
+        self._stack = []
+        self._buffer = []
+        return result, remaining
+        
+    def _is_escapable(self, c, delim=None):
+        if delim is None:
+            if self._heredoc:
+                # Backslashes works as if they were double quoted in unquoted
+                # here-documents
+                delim = '"'
+            else:
+                if len(self._stack)<=1:
+                    return True
+                delim = self._stack[-2][0]
+            
+        escapables = self.ESCAPABLE.get(delim, None)
+        return escapables is None or c in escapables
+        
+    def _parse_squote(self, buf, result, eof):
+        if not buf:
+            raise NeedMore()
+        try:
+            pos = buf.index("'")
+        except ValueError:
+            raise NeedMore()
+        result[-1] += ''.join(buf[:pos])
+        result += ["'"]
+        return pos+1, True
+        
+    def _parse_bquote(self, buf, result, eof):
+        if not buf:
+            raise NeedMore()
+            
+        if buf[0]=='\n':
+            #Remove line continuations
+            result[:] = ['', '', '']
+        elif self._is_escapable(buf[0]):
+            result[-1] += buf[0]
+            result += ['']
+        else:
+            #Keep as such
+            result[:] = ['', '\\'+buf[0], '']
+        
+        return 1, True
+        
+    def _parse_dquote(self, buf, result, eof):
+        if not buf:
+            raise NeedMore()
+        pos, sep = find_chars(buf, '$\\`"')
+        if pos==-1:
+            raise NeedMore()
+            
+        result[-1] += ''.join(buf[:pos])
+        if sep=='"':
+            result += ['"']
+            return pos+1, True
+        else:
+            #Keep everything until the separator and defer processing
+            return pos, False
+            
+    def _parse_command(self, buf, result, eof):
+        if not buf:
+            raise NeedMore()
+
+        chars = '$\\`"\''
+        if result[0] == '$(':
+            chars += ')'
+        pos, sep = find_chars(buf, chars)
+        if pos == -1:
+            raise NeedMore()
+            
+        result[-1] += ''.join(buf[:pos])
+        if (result[0]=='$(' and sep==')') or (result[0]=='`' and sep=='`'):
+            result += [sep]
+            return pos+1, True
+        else:
+            return pos, False
+            
+    def _parse_parameter(self, buf, result, eof):
+        if not buf:
+            raise NeedMore()
+            
+        pos, sep = find_chars(buf, '$\\`"\'}')
+        if pos==-1:
+            raise NeedMore()
+            
+        result[-1] += ''.join(buf[:pos])
+        if sep=='}':
+            result += [sep]
+            return pos+1, True
+        else:
+            return pos, False
+            
+    def _parse_dollar(self, buf, result, eof):
+        sep = result[0]
+        if sep=='$':            
+            if not buf:
+                #TODO: handle empty $
+                raise NeedMore()
+            if buf[0]=='(':
+                if len(buf)==1:
+                    raise NeedMore()
+                    
+                if buf[1]=='(':
+                    result[0] = '$(('
+                    buf[:2] = []
+                else:
+                    result[0] = '$('
+                    buf[:1] = []
+                
+            elif buf[0]=='{':
+                result[0] = '${'
+                buf[:1] = []
+            else:
+                if buf[0] in self.SPECIAL_CHARSET:
+                    result[-1] = buf[0]
+                    read = 1
+                else:
+                    for read,c in enumerate(buf):
+                        if c not in self.NAME_CHARSET:
+                            break
+                    else:
+                        if not eof:
+                            raise NeedMore()
+                        read += 1
+                        
+                    result[-1] += ''.join(buf[0:read])
+                    
+                if not result[-1]:
+                    result[:] = ['', result[0], '']
+                else:
+                    result += [''] 
+                return read,True
+        
+        sep = result[0]    
+        if sep=='$(':
+            parsefunc = self._parse_command
+        elif sep=='${':
+            parsefunc = self._parse_parameter
+        else:
+            raise NotImplementedError()
+            
+        pos, closed = parsefunc(buf, result, eof)
+        return pos, closed
+
+    def _parse(self, eof):
+        buf = self._buffer
+        stack = self._stack
+        recurse = False
+    
+        while 1:
+            if not stack or recurse:
+                if not buf:
+                    raise NeedMore()
+                if buf[0] not in ('"\\`$\''):
+                    raise ShellSyntaxError('Invalid quoted string sequence')
+                stack.append([buf[0], ''])
+                buf[:1] = []
+                recurse = False
+                
+            result = stack[-1]
+            if result[0]=="'":
+                parsefunc = self._parse_squote
+            elif result[0]=='\\':
+                parsefunc = self._parse_bquote
+            elif result[0]=='"':
+                parsefunc = self._parse_dquote
+            elif result[0]=='`':
+                parsefunc = self._parse_command
+            elif result[0][0]=='$':
+                parsefunc = self._parse_dollar
+            else:
+                raise NotImplementedError()
+                
+            read, closed = parsefunc(buf, result, eof)
+                
+            buf[:read] = []
+            if closed:
+                if len(stack)>1:
+                    #Merge in parent expression
+                    parsed = stack.pop()
+                    stack[-1] += [parsed]
+                    stack[-1] += ['']
+                else:
+                    break
+            else:
+                recurse = True
+
+def normalize_wordtree(wtree):
+    """Fold back every literal sequence (delimited with empty strings) into
+    parent sequence.
+    """
+    def normalize(wtree):
+        result = []
+        for part in wtree[1:-1]:
+            if isinstance(part, list):
+                part = normalize(part)
+                if part[0]=='':
+                    #Move the part content back at current level
+                    result += part[1:-1]
+                    continue
+            elif not part:
+                #Remove empty strings
+                continue
+            result.append(part)
+        if not result:
+            result = ['']    
+        return [wtree[0]] + result + [wtree[-1]]
+                
+    return normalize(wtree)
+    
+                
+def make_wordtree(token, here_document=False):
+    """Parse a delimited token and return a tree similar to the ones returned by
+    WordLexer. token may contain any combinations of expansion/quoted fields and
+    non-ones.
+    """    
+    tree = ['']
+    remaining = token
+    delimiters = '\\$`'
+    if not here_document:
+        delimiters += '\'"'
+    
+    while 1:
+        pos, sep = find_chars(remaining, delimiters)
+        if pos==-1:
+            tree += [remaining, '']
+            return normalize_wordtree(tree)
+        tree.append(remaining[:pos])
+        remaining = remaining[pos:]
+        
+        try:
+            result, remaining = WordLexer(heredoc = here_document).add(remaining, True)
+        except NeedMore:
+            raise ShellSyntaxError('Invalid token "%s"')
+        tree.append(result)
+        
+                
+def wordtree_as_string(wtree):
+    """Rewrite an expression tree generated by make_wordtree as string."""
+    def visit(node, output):
+        for child in node:
+            if isinstance(child, list):
+                visit(child, output)
+            else:
+                output.append(child)
+    
+    output = []
+    visit(wtree, output)
+    return ''.join(output)
+    
+    
+def unquote_wordtree(wtree):
+    """Fold the word tree while removing quotes everywhere. Other expansion
+    sequences are joined as such.
+    """
+    def unquote(wtree):
+        unquoted = []
+        if wtree[0] in ('', "'", '"', '\\'):
+            wtree = wtree[1:-1]
+            
+        for part in wtree:
+            if isinstance(part, list):
+                part = unquote(part)
+            unquoted.append(part)
+        return ''.join(unquoted)
+            
+    return unquote(wtree)
+    
+    
+class HereDocLexer:
+    """HereDocLexer delimits whatever comes from the here-document starting newline
+    not included to the closing delimiter line included.
+    """
+    def __init__(self, op, delim):
+        assert op in ('<<', '<<-')
+        if not delim:
+            raise ShellSyntaxError('invalid here document delimiter %s' % str(delim))
+            
+        self._op = op
+        self._delim = delim
+        self._buffer = []
+        self._token = []
+        
+    def add(self, data, eof):
+        """If the here-document was delimited, return a tuple (content, remaining).
+        Raise NeedMore() otherwise.
+        """
+        self._buffer += list(data)
+        self._parse(eof)
+        token = ''.join(self._token)
+        remaining = ''.join(self._buffer)
+        self._token, self._remaining = [], []
+        return token, remaining
+    
+    def _parse(self, eof):
+        while 1:
+            #Look for first unescaped newline. Quotes may be ignored
+            escaped = False
+            for i,c in enumerate(self._buffer):
+                if escaped:
+                    escaped = False
+                elif c=='\\':
+                    escaped = True
+                elif c=='\n':
+                    break
+            else:
+                i = -1
+                    
+            if i==-1 or self._buffer[i]!='\n':
+                if not eof:
+                    raise NeedMore()
+                #No more data, maybe the last line is closing delimiter
+                line = ''.join(self._buffer)
+                eol = ''
+                self._buffer[:] = []
+            else:
+                line = ''.join(self._buffer[:i])
+                eol = self._buffer[i]
+                self._buffer[:i+1] = []
+            
+            if self._op=='<<-':
+                line = line.lstrip('\t')
+                
+            if line==self._delim:
+                break
+                
+            self._token += [line, eol]
+            if i==-1:
+                break
+    
+class Token:
+    #TODO: check this is still in use
+    OPERATOR = 'OPERATOR'
+    WORD = 'WORD'
+    
+    def __init__(self):
+        self.value = ''
+        self.type = None
+        
+    def __getitem__(self, key):
+        #Behave like a two elements tuple
+        if key==0:
+            return self.type
+        if key==1:
+            return self.value
+        raise IndexError(key)
+               
+               
+class HereDoc:
+    def __init__(self, op, name=None):
+        self.op = op
+        self.name = name
+        self.pendings = []
+               
+TK_COMMA        = 'COMMA'
+TK_AMPERSAND    = 'AMP'
+TK_OP           = 'OP'
+TK_TOKEN        = 'TOKEN'
+TK_COMMENT      = 'COMMENT'
+TK_NEWLINE      = 'NEWLINE' 
+TK_IONUMBER     = 'IO_NUMBER'
+TK_ASSIGNMENT   = 'ASSIGNMENT_WORD'
+TK_HERENAME     = 'HERENAME'
+
+class Lexer:
+    """Main lexer.
+    
+    Call add() until the script AST is returned.
+    """
+    # Here-document handling makes the whole thing more complex because they basically
+    # force tokens to be reordered: here-content must come right after the operator
+    # and the here-document name, while some other tokens might be following the
+    # here-document expression on the same line.
+    #
+    # So, here-doc states are basically:
+    #   *self._state==ST_NORMAL
+    #       - self._heredoc.op is None: no here-document
+    #       - self._heredoc.op is not None but name is: here-document operator matched,
+    #           waiting for the document name/delimiter
+    #       - self._heredoc.op and name are not None: here-document is ready, following
+    #           tokens are being stored and will be pushed again when the document is
+    #           completely parsed.
+    #   *self._state==ST_HEREDOC
+    #       - The here-document is being delimited by self._herelexer. Once it is done
+    #           the content is pushed in front of the pending token list then all these
+    #           tokens are pushed once again.
+    ST_NORMAL       = 'ST_NORMAL'
+    ST_OP           = 'ST_OP'
+    ST_BACKSLASH    = 'ST_BACKSLASH'
+    ST_QUOTED       = 'ST_QUOTED'
+    ST_COMMENT      = 'ST_COMMENT'
+    ST_HEREDOC      = 'ST_HEREDOC'
+    
+    #Match end of backquote strings
+    RE_BACKQUOTE_END = re.compile(r'(?<!\\)(`)')
+
+    def __init__(self, parent_state = None):
+        self._input = []
+        self._pos = 0
+        
+        self._token = ''
+        self._type = TK_TOKEN
+        
+        self._state = self.ST_NORMAL
+        self._parent_state = parent_state
+        self._wordlexer = None
+        
+        self._heredoc = HereDoc(None)
+        self._herelexer = None
+        
+        ### Following attributes are not used for delimiting token and can safely
+        ### be changed after here-document detection (see _push_toke)
+        
+        # Count the number of tokens following a 'For' reserved word. Needed to
+        # return an 'In' reserved word if it comes in third place.
+        self._for_count = None
+        
+    def add(self, data, eof=False):
+        """Feed the lexer with data.
+        
+        When eof is set to True, returns unconsumed data or raise if the lexer
+        is in the middle of a delimiting operation.
+        Raise NeedMore otherwise.
+        """
+        self._input += list(data)
+        self._parse(eof)
+        self._input[:self._pos] = []
+        return ''.join(self._input)
+        
+    def _parse(self, eof):            
+        while self._state:
+            if self._pos>=len(self._input):
+                if not eof:
+                    raise NeedMore()
+                elif self._state not in (self.ST_OP, self.ST_QUOTED, self.ST_HEREDOC):
+                    #Delimit the current token and leave cleanly
+                    self._push_token('')
+                    break
+                else:
+                    #Let the sublexer handle the eof themselves
+                    pass
+                
+            if self._state==self.ST_NORMAL:
+                self._parse_normal()
+            elif self._state==self.ST_COMMENT:
+                self._parse_comment()
+            elif self._state==self.ST_OP:
+                self._parse_op(eof)
+            elif self._state==self.ST_QUOTED:
+                self._parse_quoted(eof)
+            elif self._state==self.ST_HEREDOC:
+                self._parse_heredoc(eof)
+            else:
+                assert False, "Unknown state " + str(self._state)
+                
+        if self._heredoc.op is not None:
+            raise ShellSyntaxError('missing here-document delimiter')
+                
+    def _parse_normal(self):
+        c = self._input[self._pos]
+        if c=='\n':
+            self._push_token(c)
+            self._token = c
+            self._type = TK_NEWLINE
+            self._push_token('')
+            self._pos += 1
+        elif c in ('\\', '\'', '"', '`', '$'):
+            self._state = self.ST_QUOTED
+        elif is_partial_op(c):
+            self._push_token(c)
+            
+            self._type = TK_OP
+            self._token += c
+            self._pos += 1
+            self._state = self.ST_OP
+        elif is_blank(c):
+            self._push_token(c)
+            
+            #Discard blanks
+            self._pos += 1
+        elif self._token:
+            self._token += c
+            self._pos += 1
+        elif c=='#':
+            self._state = self.ST_COMMENT
+            self._type = TK_COMMENT
+            self._pos += 1
+        else:
+            self._pos += 1
+            self._token += c          
+                
+    def _parse_op(self, eof):
+        assert self._token
+        
+        while 1:
+            if self._pos>=len(self._input):
+                if not eof:
+                    raise NeedMore()
+                c = ''
+            else:                
+                c = self._input[self._pos]
+                
+            op = self._token + c
+            if c and is_partial_op(op):
+                #Still parsing an operator
+                self._token = op
+                self._pos += 1
+            else:            
+                #End of operator
+                self._push_token(c)                    
+                self._state = self.ST_NORMAL
+                break
+                
+    def _parse_comment(self):
+        while 1:
+            if self._pos>=len(self._input):
+                raise NeedMore()
+                
+            c = self._input[self._pos]
+            if c=='\n':
+                #End of comment, do not consume the end of line
+                self._state = self.ST_NORMAL
+                break
+            else:
+                self._token += c
+                self._pos += 1
+                
+    def _parse_quoted(self, eof):
+        """Precondition: the starting backquote/dollar is still in the input queue."""
+        if not self._wordlexer:
+            self._wordlexer = WordLexer()
+        
+        if self._pos<len(self._input):
+             #Transfer input queue character into the subparser
+            input = self._input[self._pos:]
+            self._pos += len(input)
+            
+        wtree, remaining = self._wordlexer.add(input, eof)
+        self._wordlexer = None
+        self._token += wordtree_as_string(wtree)
+        
+        #Put unparsed character back in the input queue
+        if remaining:
+            self._input[self._pos:self._pos] = list(remaining)          
+        self._state = self.ST_NORMAL
+        
+    def _parse_heredoc(self, eof):
+        assert not self._token
+        
+        if self._herelexer is None:
+            self._herelexer = HereDocLexer(self._heredoc.op, self._heredoc.name)
+        
+        if self._pos<len(self._input):
+             #Transfer input queue character into the subparser
+            input = self._input[self._pos:]
+            self._pos += len(input)
+        
+        self._token, remaining = self._herelexer.add(input, eof)
+        
+        #Reset here-document state
+        self._herelexer = None
+        heredoc, self._heredoc = self._heredoc, HereDoc(None)
+        if remaining:
+            self._input[self._pos:self._pos] = list(remaining)
+        self._state = self.ST_NORMAL
+        
+        #Push pending tokens
+        heredoc.pendings[:0] = [(self._token, self._type, heredoc.name)]
+        for token, type, delim in heredoc.pendings:
+            self._token = token
+            self._type = type
+            self._push_token(delim)
+                     
+    def _push_token(self, delim):
+        if not self._token:
+            return 0
+            
+        if self._heredoc.op is not None:
+            if self._heredoc.name is None:
+                #Here-document name
+                if self._type!=TK_TOKEN:
+                    raise ShellSyntaxError("expecting here-document name, got '%s'" % self._token)
+                self._heredoc.name = unquote_wordtree(make_wordtree(self._token))
+                self._type = TK_HERENAME
+            else:
+                #Capture all tokens until the newline starting the here-document
+                if self._type==TK_NEWLINE:
+                    assert self._state==self.ST_NORMAL
+                    self._state = self.ST_HEREDOC    
+                
+                self._heredoc.pendings.append((self._token, self._type, delim))    
+                self._token = ''
+                self._type = TK_TOKEN
+                return 1
+                
+        # BEWARE: do not change parser state from here to the end of the function:
+        # when parsing between an here-document operator to the end of the line
+        # tokens are stored in self._heredoc.pendings. Therefore, they will not
+        # reach the section below.
+                    
+        #Check operators
+        if self._type==TK_OP:
+            #False positive because of partial op matching
+            op = is_op(self._token)
+            if not op:
+                self._type = TK_TOKEN
+            else:
+                #Map to the specific operator
+                self._type = op
+                if self._token in ('<<', '<<-'):
+                    #Done here rather than in _parse_op because there is no need
+                    #to change the parser state since we are still waiting for
+                    #the here-document name
+                    if self._heredoc.op is not None:
+                        raise ShellSyntaxError("syntax error near token '%s'" % self._token)
+                    assert self._heredoc.op is None
+                    self._heredoc.op = self._token
+                
+        if self._type==TK_TOKEN:            
+            if '=' in self._token and not delim:
+                if self._token.startswith('='):
+                    #Token is a WORD... a TOKEN that is.
+                    pass
+                else:
+                    prev = self._token[:self._token.find('=')]
+                    if is_name(prev):
+                        self._type = TK_ASSIGNMENT
+                    else:
+                        #Just a token (unspecified)
+                        pass
+            else:
+                reserved = get_reserved(self._token)
+                if reserved is not None:
+                    if reserved=='In' and self._for_count!=2:
+                        #Sorry, not a reserved word after all
+                        pass
+                    else:
+                        self._type = reserved
+                        if reserved in ('For', 'Case'):
+                            self._for_count = 0                    
+                elif are_digits(self._token) and delim in ('<', '>'):
+                    #Detect IO_NUMBER
+                    self._type = TK_IONUMBER
+                elif self._token==';':
+                    self._type = TK_COMMA
+                elif self._token=='&':
+                    self._type = TK_AMPERSAND
+        elif self._type==TK_COMMENT:
+            #Comments are not part of sh grammar, ignore them
+            self._token = ''
+            self._type = TK_TOKEN
+            return 0
+        
+        if self._for_count is not None:
+            #Track token count in 'For' expression to detect 'In' reserved words.
+            #Can only be in third position, no need to go beyond
+            self._for_count += 1
+            if self._for_count==3:
+                self._for_count = None
+                
+        self.on_token((self._token, self._type))
+        self._token = ''
+        self._type = TK_TOKEN
+        return 1
+                        
+    def on_token(self, token):
+        raise NotImplementedError
+                 
+
+tokens = [
+    TK_TOKEN,
+# To silence yacc unused token warnings
+#    TK_COMMENT,
+    TK_NEWLINE,
+    TK_IONUMBER,
+    TK_ASSIGNMENT,
+    TK_HERENAME,
+]            
+
+#Add specific operators
+tokens += _OPERATORS.values()
+#Add reserved words
+tokens += _RESERVEDS.values()
+            
+class PLYLexer(Lexer):
+    """Bridge Lexer and PLY lexer interface."""
+    def __init__(self):
+        Lexer.__init__(self)
+        self._tokens = []
+        self._current = 0
+        self.lineno = 0
+
+    def on_token(self, token):
+        value, type = token
+
+        self.lineno = 0
+        t = lex.LexToken()
+        t.value = value
+        t.type = type
+        t.lexer = self
+        t.lexpos = 0
+        t.lineno = 0
+        
+        self._tokens.append(t)
+        
+    def is_empty(self):
+        return not bool(self._tokens)
+        
+    #PLY compliant interface
+    def token(self):
+        if self._current>=len(self._tokens):
+            return None
+        t = self._tokens[self._current]
+        self._current += 1
+        return t      
+        
+        
+def get_tokens(s):
+    """Parse the input string and return a tuple (tokens, unprocessed) where
+    tokens is a list of parsed tokens and unprocessed is the part of the input
+    string left untouched by the lexer.
+    """
+    lexer = PLYLexer()
+    untouched = lexer.add(s, True) 
+    tokens = []
+    while 1:
+        token = lexer.token()
+        if token is None:
+            break
+        tokens.append(token)
+        
+    tokens = [(t.value, t.type) for t in tokens]
+    return tokens, untouched        
--- a/bitbake/lib/pysh/pyshyacc.py
+++ b/bitbake/lib/pysh/pyshyacc.py
@@ -0,0 +1,772 @@
+# pyshyacc.py - PLY grammar definition for pysh
+#
+# Copyright 2007 Patrick Mezard
+#
+# This software may be used and distributed according to the terms
+# of the GNU General Public License, incorporated herein by reference.
+
+"""PLY grammar file.
+"""
+import sys
+
+import pyshlex
+tokens = pyshlex.tokens
+
+from ply import yacc
+import sherrors
+    
+class IORedirect:
+    def __init__(self, op, filename, io_number=None):
+        self.op = op
+        self.filename = filename
+        self.io_number = io_number
+        
+class HereDocument:
+    def __init__(self, op, name, content, io_number=None):
+        self.op = op
+        self.name = name
+        self.content = content
+        self.io_number = io_number
+
+def make_io_redirect(p):
+    """Make an IORedirect instance from the input 'io_redirect' production."""
+    name, io_number, io_target = p
+    assert name=='io_redirect'
+    
+    if io_target[0]=='io_file':
+        io_type, io_op, io_file = io_target
+        return IORedirect(io_op, io_file, io_number)
+    elif io_target[0]=='io_here':
+        io_type, io_op, io_name, io_content = io_target
+        return HereDocument(io_op, io_name, io_content, io_number)
+    else:
+        assert False, "Invalid IO redirection token %s" % repr(io_type)
+        
+class SimpleCommand:
+    """
+    assigns contains (name, value) pairs.
+    """
+    def __init__(self, words, redirs, assigns):
+        self.words = list(words)
+        self.redirs = list(redirs)
+        self.assigns = list(assigns)
+
+class Pipeline:
+    def __init__(self, commands, reverse_status=False):
+        self.commands = list(commands)
+        assert self.commands    #Grammar forbids this
+        self.reverse_status = reverse_status
+        
+class AndOr:
+    def __init__(self, op, left, right):
+        self.op = str(op)
+        self.left = left
+        self.right = right
+        
+class ForLoop:
+    def __init__(self, name, items, cmds):
+        self.name = str(name)
+        self.items = list(items)
+        self.cmds = list(cmds)
+        
+class WhileLoop:
+    def __init__(self, condition, cmds):
+        self.condition = list(condition)
+        self.cmds = list(cmds)
+        
+class UntilLoop:
+    def __init__(self, condition, cmds):
+        self.condition = list(condition)
+        self.cmds = list(cmds)
+
+class FunDef:
+    def __init__(self, name, body):
+        self.name = str(name)
+        self.body = body
+        
+class BraceGroup:
+    def __init__(self, cmds):
+        self.cmds = list(cmds)
+        
+class IfCond:
+    def __init__(self, cond, if_cmds, else_cmds):
+        self.cond = list(cond)
+        self.if_cmds = if_cmds
+        self.else_cmds = else_cmds
+
+class Case:
+    def __init__(self, name, items):
+        self.name = name
+        self.items = items
+        
+class SubShell:
+    def __init__(self, cmds):
+        self.cmds = cmds
+
+class RedirectList:
+    def __init__(self, cmd, redirs):
+        self.cmd = cmd
+        self.redirs = list(redirs)
+        
+def get_production(productions, ptype):
+    """productions must be a list of production tuples like (name, obj) where
+    name is the production string identifier.
+    Return the first production named 'ptype'. Raise KeyError if None can be
+    found.
+    """
+    for production in productions:
+        if production is not None and production[0]==ptype:
+            return production
+    raise KeyError(ptype)
+    
+#-------------------------------------------------------------------------------
+# PLY grammar definition
+#-------------------------------------------------------------------------------
+
+def p_multiple_commands(p):
+    """multiple_commands : newline_sequence
+                         | complete_command
+                         | multiple_commands complete_command"""
+    if len(p)==2:
+        if p[1] is not None:
+            p[0] = [p[1]]
+        else:
+            p[0] = []
+    else:
+        p[0] = p[1] + [p[2]]
+
+def p_complete_command(p):
+    """complete_command : list separator
+                        | list"""
+    if len(p)==3 and p[2] and p[2][1] == '&':
+        p[0] = ('async', p[1])
+    else:
+        p[0] = p[1]
+                 
+def p_list(p):
+    """list : list separator_op and_or
+            |                   and_or"""
+    if len(p)==2:
+        p[0] = [p[1]]
+    else:
+        #if p[2]!=';':
+        #    raise NotImplementedError('AND-OR list asynchronous execution is not implemented')
+        p[0] = p[1] + [p[3]]
+       
+def p_and_or(p):
+    """and_or : pipeline
+              | and_or AND_IF linebreak pipeline
+              | and_or OR_IF  linebreak pipeline"""
+    if len(p)==2:
+        p[0] = p[1]
+    else:
+        p[0] = ('and_or', AndOr(p[2], p[1], p[4]))
+        
+def p_maybe_bang_word(p):
+    """maybe_bang_word : Bang"""
+    p[0] = ('maybe_bang_word', p[1])
+            
+def p_pipeline(p):
+    """pipeline : pipe_sequence
+                | bang_word pipe_sequence"""
+    if len(p)==3:
+        p[0] = ('pipeline', Pipeline(p[2][1:], True))
+    else:
+        p[0] = ('pipeline', Pipeline(p[1][1:]))
+
+def p_pipe_sequence(p):
+    """pipe_sequence : command
+                     | pipe_sequence PIPE linebreak command"""
+    if len(p)==2:
+        p[0] = ['pipe_sequence', p[1]]
+    else:
+        p[0] = p[1] + [p[4]]
+
+def p_command(p):
+    """command : simple_command
+               | compound_command
+               | compound_command redirect_list
+               | function_definition"""
+        
+    if p[1][0] in ( 'simple_command', 
+                    'for_clause',
+                    'while_clause',
+                    'until_clause',
+                    'case_clause',
+                    'if_clause',
+                    'function_definition',
+                    'subshell',
+                    'brace_group',):
+        if len(p) == 2:
+            p[0] = p[1]
+        else:
+            p[0] = ('redirect_list', RedirectList(p[1], p[2][1:]))
+    else:
+        raise NotImplementedError('%s command is not implemented' % repr(p[1][0]))
+
+def p_compound_command(p):
+    """compound_command : brace_group
+                        | subshell
+                        | for_clause
+                        | case_clause
+                        | if_clause
+                        | while_clause
+                        | until_clause"""
+    p[0] = p[1]
+
+def p_subshell(p):
+    """subshell : LPARENS compound_list RPARENS"""
+    p[0] = ('subshell', SubShell(p[2][1:]))
+
+def p_compound_list(p):
+    """compound_list : term
+                     | newline_list term
+                     |              term separator
+                     | newline_list term separator"""
+    productions = p[1:]           
+    try:
+        sep = get_production(productions, 'separator')
+        if sep[1]!=';':
+            raise NotImplementedError()
+    except KeyError:
+        pass
+    term = get_production(productions, 'term')
+    p[0] = ['compound_list'] + term[1:]
+
+def p_term(p):
+    """term : term separator and_or
+            |                and_or"""
+    if len(p)==2:
+        p[0] = ['term', p[1]]
+    else:
+        if p[2] is not None and p[2][1] == '&':
+            p[0] = ['term', ('async', p[1][1:])] + [p[3]]
+        else:
+            p[0] = p[1] + [p[3]]
+            
+def p_maybe_for_word(p):
+    # Rearrange 'For' priority wrt TOKEN. See p_for_word
+    """maybe_for_word : For"""
+    p[0] = ('maybe_for_word', p[1])
+
+def p_for_clause(p):
+    """for_clause : for_word name linebreak                            do_group
+                  | for_word name linebreak in          sequential_sep do_group
+                  | for_word name linebreak in wordlist sequential_sep do_group"""
+    productions = p[1:]
+    do_group = get_production(productions, 'do_group')
+    try:
+        items = get_production(productions, 'in')[1:]
+    except KeyError:
+        raise NotImplementedError('"in" omission is not implemented')
+        
+    try:
+        items = get_production(productions, 'wordlist')[1:]
+    except KeyError:
+        items = []
+        
+    name = p[2]
+    p[0] = ('for_clause', ForLoop(name, items, do_group[1:]))
+
+def p_name(p):
+    """name : token""" #Was NAME instead of token
+    p[0] = p[1]
+
+def p_in(p):
+    """in : In"""
+    p[0] = ('in', p[1])
+
+def p_wordlist(p):
+    """wordlist : wordlist token
+                |          token"""
+    if len(p)==2:
+        p[0] = ['wordlist', ('TOKEN', p[1])]
+    else:
+        p[0] = p[1] + [('TOKEN', p[2])]
+
+def p_case_clause(p):
+    """case_clause : Case token linebreak in linebreak case_list    Esac
+                   | Case token linebreak in linebreak case_list_ns Esac
+                   | Case token linebreak in linebreak              Esac"""
+    if len(p) < 8:
+        items = []
+    else:
+        items = p[6][1:]
+    name = p[2]
+    p[0] = ('case_clause', Case(name, [c[1] for c in items]))
+       
+def p_case_list_ns(p):
+    """case_list_ns : case_list case_item_ns
+                    |           case_item_ns"""
+    p_case_list(p)
+      
+def p_case_list(p):
+    """case_list : case_list case_item
+                 |           case_item"""
+    if len(p)==2:
+        p[0] = ['case_list', p[1]]
+    else:
+        p[0] = p[1] + [p[2]]
+        
+def p_case_item_ns(p):
+    """case_item_ns :         pattern RPARENS               linebreak
+                    |         pattern RPARENS compound_list linebreak
+                    | LPARENS pattern RPARENS               linebreak
+                    | LPARENS pattern RPARENS compound_list linebreak"""
+    p_case_item(p)
+                 
+def p_case_item(p):
+    """case_item :         pattern RPARENS linebreak     DSEMI linebreak
+                 |         pattern RPARENS compound_list DSEMI linebreak
+                 | LPARENS pattern RPARENS linebreak     DSEMI linebreak
+                 | LPARENS pattern RPARENS compound_list DSEMI linebreak"""
+    if len(p) < 7:
+        name = p[1][1:]
+    else:
+        name = p[2][1:]
+
+    try:
+        cmds = get_production(p[1:], "compound_list")[1:]
+    except KeyError:
+        cmds = []
+
+    p[0] = ('case_item', (name, cmds))
+                 
+def p_pattern(p):
+    """pattern :              token
+               | pattern PIPE token"""
+    if len(p)==2:
+        p[0] = ['pattern', ('TOKEN', p[1])]
+    else:
+        p[0] = p[1] + [('TOKEN', p[2])]
+
+def p_maybe_if_word(p):
+    # Rearrange 'If' priority wrt TOKEN. See p_if_word
+    """maybe_if_word : If"""
+    p[0] = ('maybe_if_word', p[1])
+
+def p_maybe_then_word(p):
+    # Rearrange 'Then' priority wrt TOKEN. See p_then_word
+    """maybe_then_word : Then"""
+    p[0] = ('maybe_then_word', p[1])
+                 
+def p_if_clause(p):
+    """if_clause : if_word compound_list then_word compound_list else_part Fi
+                 | if_word compound_list then_word compound_list           Fi"""
+    else_part = []
+    if len(p)==7:
+        else_part = p[5]
+    p[0] = ('if_clause', IfCond(p[2][1:], p[4][1:], else_part))
+                 
+def p_else_part(p):
+    """else_part : Elif compound_list then_word compound_list else_part
+                 | Elif compound_list then_word compound_list
+                 | Else compound_list"""
+    if len(p)==3:
+        p[0] = p[2][1:]
+    else:
+        else_part = []
+        if len(p)==6:
+            else_part = p[5]
+        p[0] = ('elif', IfCond(p[2][1:], p[4][1:], else_part))
+                 
+def p_while_clause(p):
+    """while_clause : While compound_list do_group"""
+    p[0] = ('while_clause', WhileLoop(p[2][1:], p[3][1:]))
+    
+def p_maybe_until_word(p):
+    # Rearrange 'Until' priority wrt TOKEN. See p_until_word
+    """maybe_until_word : Until"""
+    p[0] = ('maybe_until_word', p[1])
+           
+def p_until_clause(p):
+    """until_clause : until_word compound_list do_group"""
+    p[0] = ('until_clause', UntilLoop(p[2][1:], p[3][1:]))
+                 
+def p_function_definition(p):
+    """function_definition : fname LPARENS RPARENS linebreak function_body"""
+    p[0] = ('function_definition', FunDef(p[1], p[5]))
+                 
+def p_function_body(p):
+    """function_body : compound_command
+                     | compound_command redirect_list"""
+    if len(p)!=2:
+        raise NotImplementedError('functions redirections lists are not implemented')    
+    p[0] = p[1]    
+
+def p_fname(p):
+    """fname : TOKEN""" #Was NAME instead of token
+    p[0] = p[1]
+
+def p_brace_group(p):
+    """brace_group : Lbrace compound_list Rbrace"""
+    p[0] = ('brace_group', BraceGroup(p[2][1:]))
+
+def p_maybe_done_word(p):
+    #See p_assignment_word for details.
+    """maybe_done_word : Done"""
+    p[0] = ('maybe_done_word', p[1])
+
+def p_maybe_do_word(p):
+    """maybe_do_word : Do"""
+    p[0] = ('maybe_do_word', p[1])
+
+def p_do_group(p):
+    """do_group : do_word compound_list done_word"""
+    #Do group contains a list of AndOr
+    p[0] = ['do_group'] + p[2][1:]
+
+def p_simple_command(p):
+    """simple_command : cmd_prefix cmd_word cmd_suffix
+                      | cmd_prefix cmd_word
+                      | cmd_prefix
+                      | cmd_name cmd_suffix
+                      | cmd_name"""
+    words, redirs, assigns = [], [], []
+    for e in p[1:]:
+        name = e[0]
+        if name in ('cmd_prefix', 'cmd_suffix'):
+            for sube in e[1:]:
+                subname = sube[0]
+                if subname=='io_redirect':
+                    redirs.append(make_io_redirect(sube))
+                elif subname=='ASSIGNMENT_WORD':
+                    assigns.append(sube)
+                else:
+                    words.append(sube)
+        elif name in ('cmd_word', 'cmd_name'):
+            words.append(e)
+            
+    cmd = SimpleCommand(words, redirs, assigns)
+    p[0] = ('simple_command', cmd)
+
+def p_cmd_name(p):
+    """cmd_name : TOKEN"""
+    p[0] = ('cmd_name', p[1])
+    
+def p_cmd_word(p):
+    """cmd_word : token"""
+    p[0] = ('cmd_word', p[1])
+
+def p_maybe_assignment_word(p):
+    #See p_assignment_word for details.
+    """maybe_assignment_word : ASSIGNMENT_WORD"""
+    p[0] = ('maybe_assignment_word', p[1])
+    
+def p_cmd_prefix(p):
+    """cmd_prefix :            io_redirect
+                  | cmd_prefix io_redirect
+                  |            assignment_word
+                  | cmd_prefix assignment_word"""
+    try:
+        prefix = get_production(p[1:], 'cmd_prefix')
+    except KeyError:
+        prefix = ['cmd_prefix']
+        
+    try:
+        value = get_production(p[1:], 'assignment_word')[1]
+        value = ('ASSIGNMENT_WORD', value.split('=', 1))
+    except KeyError:        
+        value = get_production(p[1:], 'io_redirect')
+    p[0] = prefix + [value]
+                                  
+def p_cmd_suffix(p):
+    """cmd_suffix   :            io_redirect
+                    | cmd_suffix io_redirect
+                    |            token
+                    | cmd_suffix token
+                    |            maybe_for_word
+                    | cmd_suffix maybe_for_word
+                    |            maybe_done_word
+                    | cmd_suffix maybe_done_word
+                    |            maybe_do_word
+                    | cmd_suffix maybe_do_word
+                    |            maybe_until_word
+                    | cmd_suffix maybe_until_word
+                    |            maybe_assignment_word
+                    | cmd_suffix maybe_assignment_word
+                    |            maybe_if_word
+                    | cmd_suffix maybe_if_word
+                    |            maybe_then_word
+                    | cmd_suffix maybe_then_word
+                    |            maybe_bang_word
+                    | cmd_suffix maybe_bang_word"""
+    try:
+        suffix = get_production(p[1:], 'cmd_suffix')
+        token = p[2]
+    except KeyError:
+        suffix = ['cmd_suffix']
+        token = p[1]
+        
+    if isinstance(token, tuple):
+        if token[0]=='io_redirect':
+            p[0] = suffix + [token]
+        else:
+            #Convert maybe_*  to TOKEN if necessary
+            p[0] = suffix + [('TOKEN', token[1])]
+    else:
+        p[0] = suffix + [('TOKEN', token)]
+                 
+def p_redirect_list(p):
+    """redirect_list : io_redirect
+                     | redirect_list io_redirect"""
+    if len(p) == 2:
+        p[0] = ['redirect_list', make_io_redirect(p[1])]
+    else:
+        p[0] = p[1] + [make_io_redirect(p[2])]
+    
+def p_io_redirect(p):
+    """io_redirect :           io_file
+                   | IO_NUMBER io_file
+                   |           io_here
+                   | IO_NUMBER io_here"""
+    if len(p)==3:
+        p[0] = ('io_redirect', p[1], p[2])
+    else:
+        p[0] = ('io_redirect', None, p[1])
+    
+def p_io_file(p):
+    #Return the tuple (operator, filename)
+    """io_file : LESS      filename
+               | LESSAND   filename
+               | GREATER   filename
+               | GREATAND  filename
+               | DGREAT    filename
+               | LESSGREAT filename
+               | CLOBBER   filename"""
+    #Extract the filename from the file
+    p[0] = ('io_file', p[1], p[2][1])
+
+def p_filename(p):
+    #Return the filename
+    """filename : TOKEN"""
+    p[0] = ('filename', p[1])
+        
+def p_io_here(p):
+    """io_here : DLESS here_end
+               | DLESSDASH here_end"""
+    p[0] = ('io_here', p[1], p[2][1], p[2][2])
+
+def p_here_end(p):
+    """here_end : HERENAME TOKEN"""
+    p[0] = ('here_document', p[1], p[2])
+    
+def p_newline_sequence(p):
+    # Nothing in the grammar can handle leading NEWLINE productions, so add
+    # this one with the lowest possible priority relatively to newline_list.
+    """newline_sequence : newline_list"""
+    p[0] = None
+    
+def p_newline_list(p):
+    """newline_list : NEWLINE
+                    | newline_list NEWLINE"""
+    p[0] = None
+                    
+def p_linebreak(p):
+    """linebreak : newline_list
+                 | empty"""
+    p[0] = None
+
+def p_separator_op(p):                 
+    """separator_op : COMMA
+                    | AMP"""
+    p[0] = p[1]
+
+def p_separator(p):
+    """separator : separator_op linebreak
+                 | newline_list"""
+    if len(p)==2:
+        #Ignore newlines
+        p[0] = None
+    else:
+        #Keep the separator operator
+        p[0] = ('separator', p[1])
+                 
+def p_sequential_sep(p):
+    """sequential_sep : COMMA linebreak
+                      | newline_list"""
+    p[0] = None
+
+# Low priority TOKEN => for_word conversion.
+# Let maybe_for_word be used as a token when necessary in higher priority
+# rules. 
+def p_for_word(p):
+    """for_word : maybe_for_word"""
+    p[0] = p[1]
+
+def p_if_word(p):
+    """if_word : maybe_if_word"""
+    p[0] = p[1]
+
+def p_then_word(p):
+    """then_word : maybe_then_word"""
+    p[0] = p[1]
+
+def p_done_word(p):
+    """done_word : maybe_done_word"""
+    p[0] = p[1]
+
+def p_do_word(p):
+    """do_word : maybe_do_word"""
+    p[0] = p[1]
+    
+def p_until_word(p):
+    """until_word : maybe_until_word"""
+    p[0] = p[1]
+    
+def p_assignment_word(p):
+    """assignment_word : maybe_assignment_word"""
+    p[0] = ('assignment_word', p[1][1])
+    
+def p_bang_word(p):
+    """bang_word : maybe_bang_word"""
+    p[0] = ('bang_word', p[1][1])
+
+def p_token(p):
+    """token : TOKEN
+             | Fi"""
+    p[0] = p[1]
+
+def p_empty(p):
+    'empty :'
+    p[0] = None
+    
+# Error rule for syntax errors
+def p_error(p):
+    msg = []
+    w = msg.append
+    w('%r\n' % p)
+    w('followed by:\n')
+    for i in range(5):
+        n = yacc.token()
+        if not n:
+            break
+        w('  %r\n' % n)
+    raise sherrors.ShellSyntaxError(''.join(msg))
+
+# Build the parser
+try:
+    import pyshtables
+except ImportError:
+    yacc.yacc(tabmodule = 'pyshtables')
+else:
+    yacc.yacc(tabmodule = 'pysh.pyshtables', write_tables = 0, debug = 0)
+
+
+def parse(input, eof=False, debug=False):
+    """Parse a whole script at once and return the generated AST and unconsumed
+    data in a tuple.
+    
+    NOTE: eof is probably meaningless for now, the parser being unable to work
+    in pull mode. It should be set to True.
+    """
+    lexer = pyshlex.PLYLexer()
+    remaining = lexer.add(input, eof)
+    if lexer.is_empty():
+        return [], remaining
+    if debug:
+        debug = 2
+    return yacc.parse(lexer=lexer, debug=debug), remaining
+
+#-------------------------------------------------------------------------------
+# AST rendering helpers
+#-------------------------------------------------------------------------------    
+
+def format_commands(v):
+    """Return a tree made of strings and lists. Make command trees easier to
+    display.
+    """
+    if isinstance(v, list):
+        return [format_commands(c) for c in v]
+    if isinstance(v, tuple):
+        if len(v)==2 and isinstance(v[0], str) and not isinstance(v[1], str):
+            if v[0] == 'async':
+                return ['AsyncList', map(format_commands, v[1])]
+            else:
+                #Avoid decomposing tuples like ('pipeline', Pipeline(...))
+                return format_commands(v[1])
+        return format_commands(list(v))
+    elif isinstance(v, IfCond):
+        name = ['IfCond']
+        name += ['if', map(format_commands, v.cond)]
+        name += ['then', map(format_commands, v.if_cmds)]
+        name += ['else', map(format_commands, v.else_cmds)]
+        return name
+    elif isinstance(v, ForLoop):
+        name = ['ForLoop']
+        name += [repr(v.name)+' in ', map(str, v.items)]
+        name += ['commands', map(format_commands, v.cmds)]
+        return name
+    elif isinstance(v, AndOr):
+        return [v.op, format_commands(v.left), format_commands(v.right)]
+    elif isinstance(v, Pipeline):
+        name = 'Pipeline'
+        if v.reverse_status:
+            name = '!' + name
+        return [name, format_commands(v.commands)]
+    elif isinstance(v, SimpleCommand):
+        name = ['SimpleCommand']
+        if v.words:                
+            name += ['words', map(str, v.words)]
+        if v.assigns:
+            assigns = [tuple(a[1]) for a in v.assigns]
+            name += ['assigns', map(str, assigns)]
+        if v.redirs:
+            name += ['redirs', map(format_commands, v.redirs)]
+        return name
+    elif isinstance(v, RedirectList):
+        name = ['RedirectList']
+        if v.redirs:
+            name += ['redirs', map(format_commands, v.redirs)]
+        name += ['command', format_commands(v.cmd)]
+        return name
+    elif isinstance(v, IORedirect):
+        return ' '.join(map(str, (v.io_number, v.op, v.filename)))
+    elif isinstance(v, HereDocument):
+        return ' '.join(map(str, (v.io_number, v.op, repr(v.name), repr(v.content))))
+    elif isinstance(v, SubShell):
+        return ['SubShell', map(format_commands, v.cmds)]
+    else:
+        return repr(v)
+             
+def print_commands(cmds, output=sys.stdout):
+    """Pretty print a command tree."""
+    def print_tree(cmd, spaces, output):
+        if isinstance(cmd, list):
+            for c in cmd:
+                print_tree(c, spaces + 3, output)              
+        else:
+            print >>output, ' '*spaces + str(cmd)
+    
+    formatted = format_commands(cmds)
+    print_tree(formatted, 0, output)
+    
+    
+def stringify_commands(cmds): 
+    """Serialize a command tree as a string.
+    
+    Returned string is not pretty and is currently used for unit tests only.
+    """   
+    def stringify(value):
+        output = []
+        if isinstance(value, list):
+            formatted = []
+            for v in value:
+                formatted.append(stringify(v))
+            formatted = ' '.join(formatted)
+            output.append(''.join(['<', formatted, '>']))
+        else:
+            output.append(value)
+        return ' '.join(output)
+            
+    return stringify(format_commands(cmds))
+    
+        
+def visit_commands(cmds, callable):
+    """Visit the command tree and execute callable on every Pipeline and 
+    SimpleCommand instances.
+    """
+    if isinstance(cmds, (tuple, list)):
+        map(lambda c: visit_commands(c,callable), cmds)
+    elif isinstance(cmds, (Pipeline, SimpleCommand)):
+        callable(cmds)
--- a/bitbake/lib/pysh/sherrors.py
+++ b/bitbake/lib/pysh/sherrors.py
@@ -0,0 +1,41 @@
+# sherrors.py - shell errors and signals
+#
+# Copyright 2007 Patrick Mezard
+#
+# This software may be used and distributed according to the terms
+# of the GNU General Public License, incorporated herein by reference.
+
+"""Define shell exceptions and error codes.
+"""
+
+class ShellError(Exception):
+    pass
+
+class ShellSyntaxError(ShellError):
+    pass
+    
+class UtilityError(ShellError):
+    """Raised upon utility syntax error (option or operand error)."""
+    pass
+   
+class ExpansionError(ShellError):
+    pass
+     
+class CommandNotFound(ShellError):
+    """Specified command was not found."""
+    pass
+    
+class RedirectionError(ShellError):
+    pass
+    
+class VarAssignmentError(ShellError):
+    """Variable assignment error."""
+    pass
+    
+class ExitSignal(ShellError):
+    """Exit signal."""
+    pass
+    
+class ReturnSignal(ShellError):
+    """Exit signal."""
+    pass
--- a/Show More
+++ b/Show More