poky.conf: Bumping SKD_VERSION

SDK_VERSION needs a bump for 1.1.1 release Signed-off-by: Elizabeth Flanagan <elizabeth.flanagan@intel.com>
documentation: Updated copyright dates and release dates.
2026-05-18 14:27:55 +02:00 · 2012-03-14 15:49:33 -07:00 · 2012-03-14 22:34:57 +00:00 · 2012-03-05 14:28:36 -08:00 · 2012-03-04 05:39:04 -08:00 · 2012-03-04 05:38:48 -08:00
7061 changed files with 383867 additions and 5048567 deletions
--- a/.gitignore
+++ b/.gitignore
@@ -1,13 +1,20 @@
 *.pyc
 *.pyo
-build/conf/local.conf
-build/tmp/
-scripts/poky-git-proxy-socks
+build*/conf/local.conf
+build*/conf/bblayers.conf
+build*/downloads
+build*/tmp/
+build*/sstate-cache
+build*/pyshtables.py
+pstage/
+scripts/oe-git-proxy-socks
 sources/
-meta-darwin
-meta-maemo
-meta-prvt*
-poky-autobuilder*
+meta-*
+!meta-skeleton
+!meta-demoapps
 *.swp
 *.orig
 *.rej
+*~
+
+
--- 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/30
+++ b/30
@@ -1,15 +1,25 @@
 Poky
 ====

-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.
+Poky is an integration of various components to form a complete prepackaged
+build system and development environment. It features support for building
+customised embedded device style images. There are reference demo images
+featuring a X11/Matchbox/GTK themed UI called Sato. The system supports
+cross-architecture application development using QEMU emulation and a
+standalone toolchain and SDK with IDE integration.

 Additional information on the specifics of hardware that Poky supports
-is available in README.hardware.
+is available in README.hardware. Further hardware support can easily be added
+in the form of layers which extend the systems capabilities in a modular way.
+
+As an integration layer Poky consists of several upstream projects such as 
+BitBake, OpenEmbedded-Core, Yocto documentation and various sources of information 
+e.g. for the hardware support. Poky is in turn a component of the Yocto Project.
+
+The Yocto Project has extensive documentation about the system including a 
+reference manual which can be found at:
+    http://yoctoproject.org/community/documentation
+
+For information about OpenEmbedded see their website:
+    http://www.openembedded.org/
+
--- a/README.hardware
+++ b/README.hardware
@@ -1,436 +1,447 @@
-                     Poky Hardware Reference Guide
-                     =============================
+                          Poky Hardware README
+                          ====================

 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.
+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.

-QEMU Emulation Images (qemuarm and qemux86)
-===========================================
+Support for additional devices is normally added by creating BSP layers - for
+more information please see the Yocto Board Support Package (BSP) Developer's
+Guide - documentation source is in documentation/bspguide or download the PDF
+from:
+
+   http://yoctoproject.org/community/documentation
+
+Support for machines other than QEMU may be moved out to separate BSP layers in
+future versions.
+
+
+QEMU Emulation Targets
+======================

 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.
+emulator in system emulation mode. Several architectures are currently
+supported:
+
+  * ARM (qemuarm)
+  * x86 (qemux86)
+  * x86-64 (qemux86-64)
+  * PowerPC (qemuppc)
+  * MIPS (qemumips)
+
+Use of the QEMU images is covered in the Poky Reference Manual. The Poky
+MACHINE setting corresponding to the target is given in brackets.
+

 Hardware Reference Boards
 =========================

-The following boards are supported by Poky:
+The following boards are supported by Poky's core layer:

-  * 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)
+  * Texas Instruments Beagleboard (beagleboard)
+  * Freescale MPC8315E-RDB (mpc8315e-rdb)
+  * Ubiquiti Networks RouterStation Pro (routerstationpro)

-For more information see board's section below. The Poky MACHINE setting
+For more information see the 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:
+The following consumer devices are supported by Poky's core layer:

-  * 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)
+  * Intel Atom based PCs and devices (atom-pc)

-For more information see board's section below. The Poky MACHINE setting
-corresponding to the board is given in brackets.
+For more information see the device's section below. The Poky MACHINE setting
+corresponding to the device 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.

+                      Specific Hardware Documentation
+                      ===============================

-                          Hardware Reference Boards
-                          =========================

-Compulab CM-X270 (cm-x270)
-==========================
+Intel Atom based PCs and devices (atom-pc)
+==========================================

-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. 
+The atom-pc MACHINE is tested on the following platforms:

-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:
+  o Asus EeePC 901
+  o Acer Aspire One
+  o Toshiba NB305
+  o Intel Embedded Development Board 1-N450 (Black Sand)

-  ARMmon > setip dhcp off
-  ARMmon > setip ip 192.168.1.203
-  ARMmon > setip mask 255.255.255.0
+and is likely to work on many unlisted Atom based devices. The MACHINE type
+supports ethernet, wifi, sound, and i915 graphics by default in addition to
+common PC input devices, busses, and so on.

-To reflash the kernel:
+Depending on the device, it can boot from a traditional hard-disk, a USB device,
+or over the network. Writing poky generated images to physical media is
+straightforward with a caveat for USB devices. The following examples assume the
+target boot device is /dev/sdb, be sure to verify this and use the correct
+device as the following commands are run as root and are not reversable.

-  ARMmon > download kernel tftp zimage 192.168.1.202
-  ARMmon > flash kernel
+USB Device:
+  1. Build a live image. This image type consists of a simple filesystem
+     without a partition table, which is suitable for USB keys, and with the
+     default setup for the atom-pc machine, this image type is built
+     automatically for any image you build. For example:

-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.
+     $ bitbake core-image-minimal

-To reflash the initrd/initramfs:
+  2. Use the "dd" utility to write the image to the raw block device. For
+     example:

-  ARMmon > download ramdisk tftp diskimage 192.168.1.202
-  ARMmon > flash ramdisk
+     # dd if=core-image-minimal-atom-pc.hddimg of=/dev/sdb

-where diskimage is the name of the initramfs image (a cpio.gz file).
+  If the device fails to boot with "Boot error" displayed, it is likely the BIOS
+  cannot understand the physical layout of the disk (or rather it expects a
+  particular layout and cannot handle anything else). There are two possible
+  solutions to this problem:

-To boot the initramfs:
+  1. Change the BIOS USB Device setting to HDD mode. The label will vary by
+     device, but the idea is to force BIOS to read the Cylinder/Head/Sector
+     geometry from the device.

-  ARMmon > ramdisk on
-  ARMmon > bootos "console=ttyS0,38400 rdinit=/sbin/init"
+  2. Without such an option, the BIOS generally boots the device in USB-ZIP
+     mode.

-To reflash the main image login to the system as user "root", then run:
+     a. Configure the USB device for USB-ZIP mode:
+     
+     # mkdiskimage -4 /dev/sdb 0 63 62

-  # ifconfig eth0 192.168.1.203
-  # tftp -g -r mainimage 192.168.1.202
-  # flash_eraseall /dev/mtd1
-  # nandwrite /dev/mtd1 mainimage
+     Where 63 and 62 are the head and sector count as reported by fdisk.
+     Remove and reinsert the device to allow the kernel to detect the new
+     partition layout.

-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.
+     b. Copy the contents of the poky image to the USB-ZIP mode device:

-The main image can then be booted with:
+     # mount -o loop core-image-minimal-atom-pc.hddimg  /tmp/image
+     # mount /dev/sdb4 /tmp/usbkey
+     # cp -rf /tmp/image/* /tmp/usbkey

-  ARMmon > bootos "console=ttyS0,38400 root=/dev/mtdblock1 rootfstype=jffs2"
+     c. Install the syslinux boot loader:

-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:
+     # syslinux /dev/sdb4

-IMAGE_FSTYPES=cpio.gz MACHINE=cm-x270 POKYLIBC=uclibc bitbake poky-image-minimal-mtdutils
+  Install the boot device in the target board and configure the BIOS to boot
+  from it.

+  For more details on the USB-ZIP scenario, see the syslinux documentation:
+  http://git.kernel.org/?p=boot/syslinux/syslinux.git;a=blob_plain;f=doc/usbkey.txt;hb=HEAD

-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.
+Texas Instruments Beagleboard (beagleboard)
+===========================================

-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.
+The Beagleboard is an ARM Cortex-A8 development board with USB, DVI-D, S-Video,
+2D/3D accelerated graphics, audio, serial, JTAG, and SD/MMC. The xM adds a
+faster CPU, more RAM, an ethernet port, more USB ports, microSD, and removes
+the NAND flash. The beagleboard MACHINE is tested on the following platforms:

+  o Beagleboard C4
+  o Beagleboard xM rev A & B

-FreeScale iMX31ADS (mx31ads)
-===========================
+The Beagleboard C4 has NAND, while the xM does not. For the sake of simplicity,
+these instructions assume you have erased the NAND on the C4 so its boot
+behavior matches that of the xM. To do this, issue the following commands from
+the u-boot prompt (note that the unlock may be unecessary depending on the
+version of u-boot installed on your board and only one of the erase commands
+will succeed):

-The correct serial port is the top-most female connector to the right of the
-ethernet socket.
+    # nand unlock
+    # nand erase
+    # nand erase.chip

-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 further tailor these instructions for your board, please refer to the
+documentation at http://www.beagleboard.org.

-To set the IP address, run:
+From a Linux system with access to the image files perform the following steps
+as root, replacing mmcblk0* with the SD card device on your machine (such as sdc
+if used via a usb card reader):

-  ip_address -l 192.168.9.2/24 -h 192.168.9.1
+  1. Partition and format an SD card:
+     # fdisk -lu /dev/mmcblk0
+     
+     Disk /dev/mmcblk0: 3951 MB, 3951034368 bytes
+     255 heads, 63 sectors/track, 480 cylinders, total 7716864 sectors
+     Units = sectors of 1 * 512 = 512 bytes
+     
+             Device Boot      Start         End      Blocks  Id System
+     /dev/mmcblk0p1   *          63      144584       72261   c Win95 FAT32 (LBA)
+     /dev/mmcblk0p2          144585      465884      160650  83 Linux

-To download a kernel called "zimage" from the TFTP server, run:
+     # mkfs.vfat -F 16 -n "boot" /dev/mmcblk0p1
+     # mke2fs -j -L "root" /dev/mmcblk0p2

-  load -r -b 0x100000 zimage
+  The following assumes the SD card partition 1 and 2 are mounted at
+  /media/boot and /media/root respectively. Removing the card and reinserting
+  it will do just that on most modern Linux desktop environments.
+  
+  The files referenced below are made available after the build in
+  build/tmp/deploy/images.

-To write the kernel to flash run:
+  2. Install the boot loaders
+     # cp MLO-beagleboard /media/boot/MLO
+     # cp u-boot-beagleboard.bin /media/boot/u-boot.bin

-  fis create kernel
+  3. Install the root filesystem
+     # tar x -C /media/root -f core-image-$IMAGE_TYPE-beagleboard.tar.bz2
+     # tar x -C /media/root -f modules-$KERNEL_VERSION-beagleboard.tgz

-To download a rootfs jffs2 image "rootfs" from the TFTP server, run:
+  4. Install the kernel uImage
+     # cp uImage-beagleboard.bin /media/boot/uImage

-  load -r -b 0x100000 rootfs
+  5. Prepare a u-boot script to simplify the boot process
+     The Beagleboard can be made to boot at this point from the u-boot command
+     shell. To automate this process, generate a user.scr script as follows.

-To write the root filesystem  to flash run:
+     Install uboot-mkimage (from uboot-mkimage on Ubuntu or uboot-tools on Fedora).

-  fis create root
+     Prepare a script config:

-To load and boot a kernel and rootfs from flash:
+     # (cat << EOF
+     setenv bootcmd 'mmc init; fatload mmc 0:1 0x80300000 uImage; bootm 0x80300000'
+     setenv bootargs 'console=tty0 console=ttyO2,115200n8 root=/dev/mmcblk0p2 rootwait rootfstype=ext3 ro'
+     boot
+     EOF
+     ) > serial-boot.cmd
+     # mkimage -A arm -O linux -T script -C none -a 0 -e 0 -n "Core Minimal" -d ./serial-boot.cmd ./boot.scr
+     # cp boot.scr /media/boot

-  fis load kernel
-  exec -b 0x100000 -l 0x200000 -c "noinitrd console=ttymxc0,115200 root=/dev/mtdblock2 rootfstype=jffs2 init=linuxrc ip=none"
+   6. Unmount the SD partitions, insert the SD card into the Beagleboard, and
+      boot the Beagleboard

-To load and boot a kernel from a TFTP server with the rootfs over NFS:
+Note: As of the 2.6.37 linux-yocto kernel recipe, the Beagleboard uses the
+      OMAP_SERIAL device (ttyO2). If you are using an older kernel, such as the
+      2.6.34 linux-yocto-stable, be sure to replace ttyO2 with ttyS2 above. You
+      should also override the machine SERIAL_CONSOLE in your local.conf in
+      order to setup the getty on the serial line:

-  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"
+      SERIAL_CONSOLE_beagleboard = "115200 ttyS2"

-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
+Freescale MPC8315E-RDB (mpc8315e-rdb)
+=====================================

-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'.
+The MPC8315 PowerPC reference platform (MPC8315E-RDB) is aimed at hardware and
+software development of network attached storage (NAS) and digital media server
+applications. The MPC8315E-RDB features the PowerQUICC II Pro processor, which
+includes a built-in security accelerator.

-If this shows no partitions then you can create them with:
+(Note: you may find it easier to order MPC8315E-RDBA; this appears to be the
+same board in an enclosure with accessories. In any case it is fully
+compatible with the instructions given here.)

-  fis init
+Setup instructions
+------------------

-The output of 'fis list' should now show:
+You will need the following:
+* NFS root setup on your workstation
+* TFTP server installed on your workstation
+* Null modem cable connected from your workstation to the first serial port
+  on the board
+* Ethernet connected to the first ethernet port on the board

-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
+--- Preparation ---

-Partitions for the kernel and rootfs need to be created:
+Note: if you have altered your board's ethernet MAC address(es) from the
+defaults, or you need to do so because you want multiple boards on the same
+network, then you will need to change the values in the dts file (patch
+linux/arch/powerpc/boot/dts/mpc8315erdb.dts within the kernel source). If
+you have left them at the factory default then you shouldn't need to do
+anything here.

-fis create -l 0x1A0000 -e 0x00100000 kernel
-fis create -l 0x5000000 -e 0x00100000 root
+--- Booting from NFS 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.
+Load the kernel and dtb (device tree blob), and boot the system as follows:

-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.
+ 1. Get the kernel (uImage-mpc8315e-rdb.bin) and dtb (uImage-mpc8315e-rdb.dtb)
+    files from the Poky build tmp/deploy directory, and make them available on
+    your TFTP server.

+ 2. Connect the board's first serial port to your workstation and then start up
+    your favourite serial terminal so that you will be able to interact with
+    the serial console. If you don't have a favourite, picocom is suggested:

-Marvell PXA3xx Zylonite (zylonite)
-==================================
+  $ picocom /dev/ttyUSB0 -b 115200

-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.
+ 3. Power up or reset the board and press a key on the terminal when prompted
+    to get to the U-Boot command line

-The following commands setup blob:
+ 4. Set up the environment in U-Boot:

-  blob> setip client 192.168.123.4
-  blob> setip server 192.168.123.5
+ => setenv ipaddr <board ip>
+ => setenv serverip <tftp server ip>
+ => setenv bootargs root=/dev/nfs rw nfsroot=<nfsroot ip>:<rootfs path> ip=<board ip>:<server ip>:<gateway ip>:255.255.255.0:mpc8315e:eth0:off console=ttyS0,115200

-To flash the kernel:
+ 5. Download the kernel and dtb, and boot:

-  blob> tftp zylonite-kernel
-  blob> nandwrite -j 0x80800000 0x60000 0x200000
+ => tftp 800000 uImage-mpc8315e-rdb.bin
+ => tftp 780000 uImage-mpc8315e-rdb.dtb
+ => bootm 800000 - 780000

-To flash the rootfs:

-  blob> tftp zylonite-rootfs
-  blob> nanderase -j 0x260000 0x5000000
-  blob> nandwrite -j 0x80800000 0x260000 <length>
+Ubiquiti Networks RouterStation Pro (routerstationpro)
+======================================================

-(where <length> is the rootfs size which will be printed by the tftp step)
+The RouterStation Pro is an Atheros AR7161 MIPS-based board. Geared towards
+networking applications, it has all of the usual features as well as three
+type IIIA mini-PCI slots and an on-board 3-port 10/100/1000 Ethernet switch,
+in addition to the 10/100/1000 Ethernet WAN port which supports
+Power-over-Ethernet.

-To boot the board:
+Setup instructions
+------------------

-  blob> nkernel
-  blob> boot
+You will need the following:
+* A serial cable - female to female (or female to male + gender changer)
+  NOTE: cable must be straight through, *not* a null modem cable.
+* USB flash drive or hard disk that is able to be powered from the
+  board's USB port.
+* tftp server installed on your workstation

+NOTE: in the following instructions it is assumed that /dev/sdb corresponds
+to the USB disk when it is plugged into your workstation. If this is not the
+case in your setup then please be careful to substitute the correct device
+name in all commands where appropriate.

-Logic iMX31 Lite Kit (mx31litekit)
-===============================
+--- Preparation ---

-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:
+1) Build an image (e.g. core-image-minimal) using "routerstationpro" as the
+MACHINE

-  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 - 
+2) Partition the USB drive so that primary partition 1 is type Linux (83).
+Minimum size depends on your root image size - core-image-minimal probably
+only needs 8-16MB, other images will need more.

+  # fdisk /dev/sdb
+  Command (m for help): p

-Phytec phyCORE-iMX31 (mx31phy)
-==============================
+  Disk /dev/sdb: 4011 MB, 4011491328 bytes
+  124 heads, 62 sectors/track, 1019 cylinders, total 7834944 sectors
+  Units = sectors of 1 * 512 = 512 bytes
+  Sector size (logical/physical): 512 bytes / 512 bytes
+  I/O size (minimum/optimal): 512 bytes / 512 bytes
+  Disk identifier: 0x0009e87d

-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.
+     Device Boot      Start         End      Blocks   Id  System
+  /dev/sdb1              62     1952751      976345   83  Linux

+3) Format partition 1 on the USB as ext3

-                             Consumer Devices
-                             ================
+  # mke2fs -j /dev/sdb1

-FIC Neo1973 GTA01 smartphone (fic-gta01)
-========================================
+4) Mount partition 1 and then extract the contents of
+tmp/deploy/images/core-image-XXXX.tar.bz2 into it (preserving permissions).

-To install Poky on a GTA01 smartphone you will need "dfu-util" tool
-which you can build with "bitbake dfu-util-native" command.
+  # mount /dev/sdb1 /media/sdb1
+  # cd /media/sdb1
+  # tar -xvjpf tmp/deploy/images/core-image-XXXX.tar.bz2

-Flashing requires these steps:
+5) Unmount the USB drive and then plug it into the board's USB port

-  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:
+6) Connect the board's serial port to your workstation and then start up
+your favourite serial terminal so that you will be able to interact with
+the serial console. If you don't have a favourite, picocom is suggested:

-     dfu-util - (C) 2007 by OpenMoko Inc.
-     This program is Free Software and has ABSOLUTELY NO WARRANTY
+  $ picocom /dev/ttyUSB0 -b 115200

-     Found Runtime: [0x1457:0x5119] devnum=19, cfg=0, intf=2, alt=0, name="USB Device Firmware Upgrade"
+7) Connect the network into eth0 (the one that is NOT the 3 port switch). If
+you are using power-over-ethernet then the board will power up at this point.

-  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) 
+8) Start up the board, watch the serial console. Hit Ctrl+C to abort the
+autostart if the board is configured that way (it is by default). The
+bootloader's fconfig command can be used to disable autostart and configure
+the IP settings if you need to change them (default IP is 192.168.1.20).

+9) Make the kernel (tmp/deploy/images/vmlinux-routerstationpro.bin) available
+on the tftp server.

-HTC Universal (htcuniversal)
-============================
+10) If you are going to write the kernel to flash (optional - see "Booting a
+kernel directly" below for the alternative), remove the current kernel and
+rootfs flash partitions. You can list the partitions using the following
+bootloader command:

-Note: HTC Universal support is highly experimental.
+  RedBoot> fis list

-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.
+You can delete the existing kernel and rootfs with these commands:

-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.
+  RedBoot> fis delete kernel
+  RedBoot> fis delete rootfs

-On the first partition you need three files:
+--- Booting a kernel directly ---

-  * 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:
+1) Load the kernel using the following bootloader command:

-set kernel "zImage"
-set mtype "855"
-set cmdline "root=/dev/mmcblk0p2 rw console=ttyS0,115200n8 console=tty0 rootdelay=5 fbcon=rotate:1"
-boot2
+  RedBoot> load -m tftp -h <ip of tftp server> vmlinux-routerstationpro.bin

-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.
+You should see a message on it being successfully loaded.

-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.
+2) Execute the kernel:

+  RedBoot> exec -c "console=ttyS0,115200 root=/dev/sda1 rw rootdelay=2 board=UBNT-RSPRO"

-Nokia 770/N800/N810 Internet Tablets (nokia770 and nokia800)
-============================================================
+Note that specifying the command line with -c is important as linux-yocto does
+not provide a default command line.

-Note: Nokia tablet support is highly experimental.
+--- Writing a kernel to flash ---

-The Nokia internet tablet devices are OMAP based tablet formfactor devices 
-with large screens (800x480), wifi and touchscreen.
+1) Go to your tftp server and gzip the kernel you want in flash. It should
+halve the size.

-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:
+2) Load the kernel using the following bootloader command:

-  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.
+  RedBoot> load -r -b 0x80600000 -m tftp -h <ip of tftp server> vmlinux-routerstationpro.bin.gz

-The nokia800 images and kernel will run on both the N800 and N810.
+This should output something similar to the following:

+  Raw file loaded 0x80600000-0x8087c537, assumed entry at 0x80600000

-Sharp Zaurus SL-C7x0 series (c7x0)
-==================================
+Calculate the length by subtracting the first number from the second number
+and then rounding the result up to the nearest 0x1000.

-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:
+3) Using the length calculated above, create a flash partition for the kernel:

-  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":
+  RedBoot> fis create -b 0x80600000 -l 0x240000 kernel

-     $ cp ./tmp/deploy/images/poky-image-sato-c7x0.jffs2 /path/to/my-cf-card/initrd.bin
+(change 0x240000 to your rounded length -- change "kernel" to whatever
+you want to name your kernel)

-  3. Copy an Linux kernel file (zImage-c7x0.bin) onto the card as 
-     "zImage.bin":
+--- Booting a kernel from flash ---

-     $ cp ./tmp/deploy/images/zImage-c7x0.bin /path/to/my-cf-card/zImage.bin
+To boot the flashed kernel perform the following steps.

-  4. Copy an updater script (updater.sh.c7x0) onto the card
-     as "updater.sh":
+1) At the bootloader prompt, load the kernel:

-     $ cp ./tmp/deploy/images/updater.sh.c7x0 /path/to/my-cf-card/updater.sh
+  RedBoot> fis load -d -e kernel

-  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.
+(Change the name "kernel" above if you chose something different earlier)

+(-e means 'elf', -d 'decompress')

-Sharp Zaurus SL-C1000 (akita)
-=============================
+2) Execute the kernel using the exec command as above.

-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
+--- Automating the boot process ---

+After writing the kernel to flash and testing the load and exec commands
+manually, you can automate the boot process with a boot script.

+1) RedBoot> fconfig
+   (Answer the questions not specified here as they pertain to your environment)
+2) Run script at boot: true
+  Boot script: 
+  .. fis load -d -e kernel
+  .. exec
+  Enter script, terminate with empty line
+  >> fis load -d -e kernel
+  >> exec -c "console=ttyS0,115200 root=/dev/sda1 rw rootdelay=2 board=UBNT-RSPRO"
+  >> 
+3) Answer the remaining questions and write the changes to flash:
+  Update RedBoot non-volatile configuration - continue (y/n)? y
+  ... Erase from 0xbfff0000-0xc0000000: .
+  ... Program from 0x87ff0000-0x88000000 at 0xbfff0000: .
+4) Power cycle the board.

--- a/bitbake-dev/AUTHORS
+++ b/bitbake-dev/AUTHORS
@@ -1,10 +0,0 @@
-Tim Ansell <mithro@mithis.net>
-Phil Blundell <pb@handhelds.org>
-Seb Frankengul <seb@frankengul.org>
-Holger Freyther <zecke@handhelds.org>
-Marcin Juszkiewicz <marcin@haerwu.biz>
-Chris Larson <kergoth@handhelds.org>
-Ulrich Luckas <luckas@musoft.de>
-Mickey Lauer <mickey@Vanille.de>
-Richard Purdie <rpurdie@rpsys.net>
-Holger Schurig <holgerschurig@gmx.de>
--- a/bitbake-dev/ChangeLog
+++ b/bitbake-dev/ChangeLog
@@ -1,315 +0,0 @@
-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)
-	- Promote certain warnings from debug to note 2 level
-	- Update manual
-	- 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 dictonary 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)
-
-Changes in Bitbake 1.8.0:
-	- Release 1.7.x as a stable series
-
-Changes in BitBake 1.7.x:
-	- Major updates of the dependency handling and execution
-	  of tasks. Code from bin/bitbake replaced with runqueue.py
-	  and taskdata.py
-	- New task execution code supports multithreading with a simplistic
-	  threading algorithm controlled by BB_NUMBER_THREADS
-	- Change of the SVN Fetcher to keep the checkout around
-	  courtsey of Paul Sokolovsky (#1367)
-	- PATH fix to bbimage (#1108)
-	- Allow debug domains to be specified on the commandline (-l)
-	- Allow 'interactive' tasks
-	- Logging message improvements
-	- Drop now uneeded BUILD_ALL_DEPS variable
-	- Add support for wildcards to -b option
-	- Major overhaul of the fetchers making a large amount of code common
-	  including mirroring code
-	- Fetchers now touch md5 stamps upon access (to show activity)
-	- Fix -f force option when used without -b (long standing bug)
-	- Add expand_cache to data_cache.py, caching expanded data (speedup)
-	- Allow version field in DEPENDS (ignored for now)
-	- Add abort flag support to the shell
-	- Make inherit fail if the class doesn't exist (#1478)
-	- Fix data.emit_env() to expand keynames as well as values
-	- Add ssh fetcher
-	- Add perforce fetcher
-	- Make PREFERRED_PROVIDER_foobar defaults to foobar if available
-	- Share the parser's mtime_cache, reducing the number of stat syscalls
-	- Compile all anonfuncs at once! 
-	  *** Anonfuncs must now use common spacing format ***
-	- Memorise the list of handlers in __BBHANDLERS and tasks in __BBTASKS
-	  This removes 2 million function calls resulting in a 5-10% speedup
-	- Add manpage
-	- Update generateDotGraph to use taskData/runQueue improving accuracy
-	  and also adding a task dependency graph
-	- Fix/standardise on GPLv2 licence
-	- Move most functionality from bin/bitbake to cooker.py and split into
-	  separate funcitons
-	- CVS fetcher: Added support for non-default port
-	- Add BBINCLUDELOGS_LINES, the number of lines to read from any logfile
-	- Drop shebangs from lib/bb scripts
-
-Changes in Bitbake 1.6.0:
-	- Better msg handling
-	- COW dict implementation from Tim Ansell (mithro) leading
-	  to better performance
-	- Speed up of -s
-
-Changes in Bitbake 1.4.4:
-	- SRCDATE now handling courtsey Justin Patrin
-	- #1017 fix to work with rm_work
-
-Changes in BitBake 1.4.2:
-	- Send logs to oe.pastebin.com instead of pastebin.com
-	  fixes #856
-	- Copy the internal bitbake data before building the
-	  dependency graph. This fixes nano not having a
-	  virtual/libc dependency
-	- Allow multiple TARBALL_STASH entries
-	- Cache, check if the directory exists before changing
-	  into it
-	- git speedup cloning by not doing a checkout
-	- allow to have spaces in filenames (.conf, .bb, .bbclass)
-
-Changes in BitBake 1.4.0:
-	- Fix to check both RDEPENDS and RDEPENDS_${PN}
-	- Fix a RDEPENDS parsing bug in utils:explode_deps()
-	- Update git fetcher behaviour to match git changes
-	- ASSUME_PROVIDED allowed to include runtime packages
-	- git fetcher cleanup and efficency improvements
-	- Change the format of the cache
-	- Update usermanual to document the Fetchers
-	- Major changes to caching with a new strategy
-	  giving a major performance increase when reparsing
-	  with few data changes
-
-Changes in BitBake 1.3.3:
-	- Create a new Fetcher module to ease the
-	  development of new Fetchers.
-	  Issue #438 fixed by rpurdie@openedhand.com
-	- Make the Subversion fetcher honor the SRC Date
-	  (CVSDATE).
-	  Issue #555 fixed by chris@openedhand.com
-	- Expand PREFERRED_PROVIDER properly
-	  Issue #436 fixed by rprudie@openedhand.com
-	- Typo fix for Issue #531 by Philipp Zabel for the
-	  BitBake Shell
-	- Introduce a new special variable SRCDATE as
-	  a generic naming to replace CVSDATE.
-	- Introduce a new keyword 'required'. In contrast
-	  to 'include' parsing will fail if a to be included
-	  file can not be found.
-	- Remove hardcoding of the STAMP directory. Patch
-	  courtsey pHilipp Zabel
-	- Track the RDEPENDS of each package (rpurdie@openedhand.com)
-	- Introduce BUILD_ALL_DEPS to build all RDEPENDS. E.g
-	  this is used by the OpenEmbedded Meta Packages.
-	  (rpurdie@openedhand.com).
-
-Changes in BitBake 1.3.2:
-	- reintegration of make.py into BitBake
-	- bbread is gone, use bitbake -e
-	- lots of shell updates and bugfixes
-	- Introduction of the .= and =. operator
-	- Sort variables, keys and groups in bitdoc
-	- Fix regression in the handling of BBCOLLECTIONS
-	- Update the bitbake usermanual
-
-Changes in BitBake 1.3.0:
-	- add bitbake interactive shell (bitbake -i)
-	- refactor bitbake utility in OO style
-	- kill default arguments in methods in the bb.data module
-	- kill default arguments in methods in the bb.fetch module
-	- the http/https/ftp fetcher will fail if the to be 
-	  downloaded file was not found in DL_DIR (this is needed
-	  to avoid unpacking the sourceforge mirror page)
-	- Switch to a cow like data instance for persistent and non
-	  persisting mode (called data_smart.py)
-	- Changed the callback of bb.make.collect_bbfiles to carry
-	  additional parameters
-	- Drastically reduced the amount of needed RAM by not holding
-	  each data instance in memory when using a cache/persistent
-	  storage
-
-Changes in BitBake 1.2.1:
-	The 1.2.1 release is meant as a intermediate release to lay the
-	ground for more radical changes. The most notable changes are:
-
-	- Do not hardcode {}, use bb.data.init() instead if you want to
-	  get a instance of a data class
-	- bb.data.init() is a factory and the old bb.data methods are delegates
-	- Do not use deepcopy use bb.data.createCopy() instead.
-	- Removed default arguments in bb.fetch
-
--- a/bitbake-dev/bin/bitbake
+++ b/bitbake-dev/bin/bitbake
@@ -1,207 +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, 2004  Chris Larson
-# Copyright (C) 2003, 2004  Phil Blundell
-# Copyright (C) 2003 - 2005 Michael 'Mickey' Lauer
-# Copyright (C) 2005        Holger Hans Peter Freyther
-# Copyright (C) 2005        ROAD GmbH
-# Copyright (C) 2006        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 sys, os, getopt, re, time, optparse, xmlrpclib
-sys.path.insert(0,os.path.join(os.path.dirname(os.path.dirname(sys.argv[0])), 'lib'))
-import bb
-from bb import cooker
-from bb import daemonize
-from bb import ui
-from bb.ui import uievent
-
-__version__ = "1.9.0"
-
-if sys.hexversion < 0x020600F0:
-    print "Sorry, python 2.6 or later is required for this version of bitbake"
-    sys.exit(1)
-
-#============================================================================#
-# BBOptions
-#============================================================================#
-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 print_exception(exc, value, tb):
-    """
-    Print the exception to stderr, only showing the traceback if bitbake
-    debugging is enabled.
-    """
-    if not bb.msg.debug_level['default']:
-        tb = None
-
-    sys.__excepthook__(exc, value, tb)
-
-
-#============================================================================#
-# main
-#============================================================================#
-
-def main():
-    return_value = 0
-    pythonver = sys.version_info
-    if pythonver[0] < 2 or (pythonver[0] == 2 and pythonver[1] < 5):
-        print "Sorry, bitbake needs python 2.5 or later."
-        sys.exit(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 separated list of files to
-be executed.  BBFILES does support wildcards.
-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( "-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( "-a", "--tryaltconfigs", help = "continue with builds by trying to use alternative providers where possible.",
-               action = "store_true", dest = "tryaltconfigs", 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( "-i", "--interactive", help = "drop into the interactive mode also called the BitBake shell.",
-               action = "store_true", dest = "interactive", 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( "-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( "-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( "-p", "--parse-only", help = "quit after parsing the BB files (developers only)",
-               action = "store_true", dest = "parse_only", 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( "-s", "--show-versions", help = "show current and preferred versions of all packages",
-               action = "store_true", dest = "show_versions", 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( "-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( "-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:])
-
-    cooker = bb.cooker.BBCooker(configuration)
-
-    # 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.parseCommandLine()
-    host = cooker.server.host
-    port = cooker.server.port
-
-    # 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")
-
-    daemonize.createDaemon(cooker.serve, cooker_logfile)
-    del cooker
-
-    # Setup a connection to the server (cooker)
-    server = xmlrpclib.Server("http://%s:%s" % (host, port),  allow_none=True)
-    # Setup an event receiving queue
-    eventHandler = uievent.BBUIEventQueue(server)
-
-    # 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.
-            exec "from bb.ui import " + ui
-            exec "return_value = " + ui + ".init(server, eventHandler)"
-    except ImportError:
-        print "FATAL: Invalid user interface '%s' specified. " % ui
-        print "Valid interfaces are 'ncurses', 'depexp' or the default, 'knotty'."
-    except Exception, e:
-        print "FATAL: Unable to start to '%s' UI: %s." % (configuration.ui, e.message)
-    finally:
-        # Don't wait for server indefinitely
-        import socket
-        socket.setdefaulttimeout(2) 
-        try:
-            eventHandler.system_quit()
-        except:
-            pass
-        try:
-            server.terminateServer()
-        except:
-            pass
-        return return_value
-
-if __name__ == "__main__":
-    print """WARNING, WARNING, WARNING
-This is a Bitbake from the Unstable/Development 1.9 Branch. This software is a work in progress and should only be used by Bitbake developers/testers"""
-
-    ret = main()
-    sys.exit(ret)
-
--- a/bitbake-dev/bin/bitdoc
+++ b/bitbake-dev/bin/bitdoc
@@ -1,534 +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) 2005 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.
-
-import optparse, os, sys
-
-# bitbake
-sys.path.append(os.path.join(os.path.dirname(os.path.dirname(sys.argv[0])), 'lib'))
-import bb
-import bb.parse
-from   string import split, join
-
-__version__ = "0.0.2"
-
-class HTMLFormatter:
-    """
-    Simple class to help to generate some sort of HTML files. It is
-    quite inferior solution compared to docbook, gtkdoc, doxygen but it
-    should work for now.
-    We've a global introduction site (index.html) and then one site for
-    the list of keys (alphabetical sorted) and one for the list of groups,
-    one site for each key with links to the relations and groups.
-
-        index.html
-        all_keys.html
-        all_groups.html
-        groupNAME.html
-        keyNAME.html
-    """
-
-    def replace(self, text, *pairs):
-        """
-        From pydoc... almost identical at least
-        """
-        while pairs:
-            (a,b) = pairs[0]
-            text = join(split(text, a), b)
-            pairs = pairs[1:]
-        return text
-    def escape(self, text):
-        """
-        Escape string to be conform HTML
-        """
-        return self.replace(text, 
-                            ('&', '&amp;'), 
-                            ('<', '&lt;' ),
-                            ('>', '&gt;' ) )
-    def createNavigator(self):
-        """
-        Create the navgiator
-        """
-        return """<table class="navigation" width="100%" summary="Navigation header" cellpadding="2" cellspacing="2">
-<tr valign="middle">
-<td><a accesskey="g" href="index.html">Home</a></td>
-<td><a accesskey="n" href="all_groups.html">Groups</a></td>
-<td><a accesskey="u" href="all_keys.html">Keys</a></td>
-</tr></table>
-"""
-
-    def relatedKeys(self, item):
-        """
-        Create HTML to link to foreign keys
-        """
-
-        if len(item.related()) == 0:
-            return ""
-
-        txt = "<p><b>See also:</b><br>"
-        txts = []
-        for it in item.related():
-            txts.append("""<a href="key%(it)s.html">%(it)s</a>""" % vars() )
-
-        return txt + ",".join(txts)
-
-    def groups(self,item):
-        """
-        Create HTML to link to related groups
-        """
-
-        if len(item.groups()) == 0:
-            return ""
-
-
-        txt = "<p><b>See also:</b><br>"
-        txts = []
-        for group in item.groups():
-            txts.append( """<a href="group%s.html">%s</a> """ % (group,group) )
-
-        return txt + ",".join(txts)
-
-
-    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.
-        """
-
-        return """<!doctype html PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
-<html><head><title>Key %s</title></head>
-<link rel="stylesheet" href="style.css" type="text/css">
-<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
-%s
-<h2><span class="refentrytitle">%s</span></h2>
-
-<div class="refsynopsisdiv">
-<h2>Synopsis</h2>
-<p>
-%s
-</p>
-</div>
-
-<div class="refsynopsisdiv">
-<h2>Related Keys</h2>
-<p>
-%s
-</p>
-</div>
-
-<div class="refsynopsisdiv">
-<h2>Groups</h2>
-<p>
-%s
-</p>
-</div>
-
-
-</body>
-"""     % (item.name(), self.createNavigator(), item.name(), 
-           self.escape(item.description()), self.relatedKeys(item), self.groups(item))
-
-    def createGroupsSite(self, doc):
-        """
-        Create the Group Overview site
-        """
-
-        groups = ""
-        sorted_groups = doc.groups()
-        sorted_groups.sort()
-        for group in sorted_groups:
-            groups += """<a href="group%s.html">%s</a><br>""" % (group, group)
-
-        return """<!doctype html PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
-<html><head><title>Group overview</title></head>
-<link rel="stylesheet" href="style.css" type="text/css">
-<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
-%s
-<h2>Available Groups</h2>
-%s
-</body>
-""" % (self.createNavigator(), groups)
-
-    def createIndex(self):
-        """
-        Create the index file
-        """
-
-        return """<!doctype html PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
-<html><head><title>Bitbake Documentation</title></head>
-<link rel="stylesheet" href="style.css" type="text/css">
-<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
-%s
-<h2>Documentation Entrance</h2>
-<a href="all_groups.html">All available groups</a><br>
-<a href="all_keys.html">All available keys</a><br>
-</body>
-""" % self.createNavigator()
-
-    def createKeysSite(self, doc):
-        """
-        Create Overview of all avilable keys
-        """
-        keys = ""
-        sorted_keys = doc.doc_keys()
-        sorted_keys.sort()
-        for key in sorted_keys:
-            keys += """<a href="key%s.html">%s</a><br>""" % (key, key)
-
-        return """<!doctype html PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
-<html><head><title>Key overview</title></head>
-<link rel="stylesheet" href="style.css" type="text/css">
-<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
-%s
-<h2>Available Keys</h2>
-%s
-</body>
-""" % (self.createNavigator(), keys)
-
-    def createGroupSite(self, gr, items, _description = None):
-        """
-        Create a site for a group:
-        Group the name of the group, items contain the name of the keys
-        inside this group
-        """
-        groups = ""
-        description = ""
-
-        # create a section with the group descriptions
-        if _description:
-            description  += "<h2 Description of Grozp %s</h2>" % gr
-            description  += _description
-
-        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())
-
-        return """<!doctype html PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
-<html><head><title>Group %s</title></head>
-<link rel="stylesheet" href="style.css" type="text/css">
-<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
-%s
-%s
-<div class="refsynopsisdiv">
-<h2>Keys in Group %s</h2>
-<pre class="synopsis">
-%s
-</pre>
-</div>
-</body>
-""" % (gr, self.createNavigator(), description, gr, groups)
-
-
-
-    def createCSS(self):
-        """
-        Create the CSS file
-        """
-        return """.synopsis, .classsynopsis
-{
-  background: #eeeeee;
-  border: solid 1px #aaaaaa;
-  padding: 0.5em;
-}
-.programlisting
-{
-  background: #eeeeff;
-  border: solid 1px #aaaaff;
-  padding: 0.5em;
-}
-.variablelist
-{
-  padding: 4px;
-  margin-left: 3em;
-}
-.variablelist td:first-child
-{
-  vertical-align: top;
-}
-table.navigation
-{
-  background: #ffeeee;
-  border: solid 1px #ffaaaa;
-  margin-top: 0.5em;
-  margin-bottom: 0.5em;
-}
-.navigation a
-{
-  color: #770000;
-}
-.navigation a:visited
-{
-  color: #550000;
-}
-.navigation .title
-{
-  font-size: 200%;
-}
-div.refnamediv
-{
-  margin-top: 2em;
-}
-div.gallery-float
-{
-  float: left;
-  padding: 10px;
-}
-div.gallery-float img
-{
-  border-style: none;
-}
-div.gallery-spacer
-{
-  clear: both;
-}
-a
-{
-  text-decoration: none;
-}
-a:hover
-{
-  text-decoration: underline;
-  color: #FF0000;
-}
-"""
-
-
-
-class DocumentationItem:
-    """
-    A class to hold information about a configuration
-    item. It contains the key name, description, a list of related names,
-    and the group this item is contained in.
-    """
-
-    def __init__(self):
-        self._groups  = []
-        self._related = []
-        self._name    = ""
-        self._desc    = ""
-
-    def groups(self):
-        return self._groups
-
-    def name(self):
-        return self._name
-
-    def description(self):
-        return self._desc
-
-    def related(self):
-        return self._related
-
-    def setName(self, name):
-        self._name = name
-
-    def setDescription(self, desc):
-        self._desc = desc
-
-    def addGroup(self, group):
-        self._groups.append(group)
-
-    def addRelation(self,relation):
-        self._related.append(relation)
-
-    def sort(self):
-        self._related.sort()
-        self._groups.sort()
-
-
-class Documentation:
-    """
-    Holds the documentation... with mappings from key to items...
-    """
-
-    def __init__(self):
-        self.__keys   = {}
-        self.__groups = {}
-
-    def insert_doc_item(self, item):
-        """
-        Insert the Doc Item into the internal list
-        of representation
-        """
-        item.sort()
-        self.__keys[item.name()] = item
-
-        for group in item.groups():
-            if not group in self.__groups:
-                self.__groups[group] = []
-            self.__groups[group].append(item)
-            self.__groups[group].sort()
-
-
-    def doc_item(self, key):
-        """
-        Return the DocumentationInstance describing the key
-        """
-        try:
-            return self.__keys[key]
-        except KeyError:
-            return None
-
-    def doc_keys(self):
-        """
-        Return the documented KEYS (names)
-        """
-        return self.__keys.keys()
-
-    def groups(self):
-        """
-        Return the names of available groups
-        """
-        return self.__groups.keys()
-
-    def group_content(self,group_name):
-        """
-        Return a list of keys/names that are in a specefic
-        group or the empty list
-        """
-        try:
-            return self.__groups[group_name]
-        except KeyError:
-            return []
-
-
-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__))
-    usage  = """%prog [options]
-
-Create a set of html pages (documentation) for a bitbake.conf....
-"""
-
-    # Add the needed options
-    parser.add_option( "-c", "--config", help = "Use the specified configuration file as source",
-                       action = "store", dest = "config", default = os.path.join("conf", "documentation.conf") )
-
-    parser.add_option( "-o", "--output", help = "Output directory for html files",
-                       action = "store", dest = "output", default = "html/" )
-
-    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",
-                       action = "store_true", dest = "verbose", default = False )
-
-    options, args = parser.parse_args( sys.argv )
-
-    if options.debug:
-        bb.msg.set_debug_level(options.debug)
-
-    return options.config, options.output
-
-def main():
-    """
-    The main Method
-    """
-
-    (config_file,output_dir) = parse_cmdline( sys.argv )
-
-    # right to let us load the file now
-    try:
-        documentation = bb.parse.handle( config_file, bb.data.init() )
-    except IOError:
-        bb.fatal( "Unable to open %s" % config_file )
-    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()
-
-    # defined states
-    state_begin = 0
-    state_see   = 1
-    state_group = 2
-
-    for key in bb.data.keys(documentation):
-        data   = bb.data.getVarFlag(key, "doc", documentation)
-        if not data:
-            continue
-
-        # The Documentation now starts
-        doc_ins = DocumentationItem()
-        doc_ins.setName(key)
-
-
-        tokens = data.split(' ')
-        state = state_begin
-        string= ""
-        for token in tokens:
-            token = token.strip(',')
-
-            if not state == state_see and token == "@see":
-                state = state_see
-                continue
-            elif not state == state_group and token  == "@group":
-                state = state_group
-                continue
-
-            if state == state_begin:
-                string += " %s" % token
-            elif state == state_see:
-                doc_ins.addRelation(token)
-            elif state == state_group:
-                doc_ins.addGroup(token)
-
-        # set the description
-        doc_ins.setDescription(string)
-        doc.insert_doc_item(doc_ins)
-
-    # let us create the HTML now
-    bb.mkdirhier(output_dir)
-    os.chdir(output_dir)
-
-    # Let us create the sites now. We do it in the following order
-    # Start with the index.html. It will point to sites explaining all
-    # keys and groups
-    html_slave = HTMLFormatter()
-
-    f = file('style.css', 'w')
-    print >> f, html_slave.createCSS()
-
-    f = file('index.html', 'w')
-    print >> f, html_slave.createIndex()
-
-    f = file('all_groups.html', 'w')
-    print >> f, html_slave.createGroupsSite(doc)
-
-    f = file('all_keys.html', 'w')
-    print >> f, html_slave.createKeysSite(doc)
-
-    # now for each group create the site
-    for group in doc.groups():
-        f = file('group%s.html' % group, 'w')
-        print >> f, html_slave.createGroupSite(group, doc.group_content(group))
-
-    # now for the keys
-    for key in doc.doc_keys():
-        f = file('key%s.html' % doc.doc_item(key).name(), 'w')
-        print >> f, html_slave.createKeySite(doc.doc_item(key))
-
-
-if __name__ == "__main__":
-    main()
--- a/bitbake-dev/lib/bb/COW.py
+++ b/bitbake-dev/lib/bb/COW.py
@@ -1,318 +0,0 @@
-# ex:ts=4:sw=4:sts=4:et
-# -*- tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*-
-#
-# This is a copy on write dictionary and set which abuses classes to try and be nice and fast.
-#
-# 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
-# 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.
-#
-#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.
-#
-
-import copy
-import types
-types.ImmutableTypes = tuple([ \
-    types.BooleanType, \
-    types.ComplexType, \
-    types.FloatType, \
-    types.IntType, \
-    types.LongType, \
-    types.NoneType, \
-    types.TupleType, \
-    frozenset] + \
-    list(types.StringTypes))
-
-MUTABLE = "__mutable__"
-
-class COWMeta(type):
-    pass
- 
-class COWDictMeta(COWMeta):
-    __warn__ = False
-    __hasmutable__ = False
-    __marker__ = tuple()
-
-    def __str__(cls):
-        # FIXME: I have magic numbers!
-        return "<COWDict Level: %i Current Keys: %i>" % (cls.__count__, len(cls.__dict__) - 3)
-    __repr__ = __str__
-
-    def cow(cls):
-        class C(cls):
-            __count__ = cls.__count__ + 1
-        return C
-    copy = cow
-    __call__ = cow
-
-    def __setitem__(cls, key, value):
-        if not isinstance(value, types.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:
-            return cls.__dict__[nkey]
-        except KeyError:
-            pass
-
-        value = getattr(cls, nkey)
-        if readonly:
-            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
-        try:
-            value = value.copy()
-        except AttributeError, e:
-            value = copy.copy(value)
-        setattr(cls, nkey, value)
-        return value
-
-    __getmarker__ = []
-    def __getreadonly__(cls, key, default=__getmarker__):
-        """\
-        Get a value (even if mutable) which you promise not to change.
-        """
-        return cls.__getitem__(key, default, True)
-
-    def __getitem__(cls, key, default=__getmarker__, readonly=False):
-        try:
-            try:
-                value = getattr(cls, key)
-            except AttributeError:
-                value = cls.__getmutable__(key, readonly)
-            
-            # 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:
-            if not default is cls.__getmarker__:
-                return default
-
-            raise KeyError(str(e))
-
-    def __delitem__(cls, key):
-        cls.__setitem__(key, cls.__marker__)
-
-    def __revertitem__(cls, key):
-        if not cls.__dict__.has_key(key):
-            key += MUTABLE
-        delattr(cls, key)
-
-    def has_key(cls, key):
-        value = cls.__getreadonly__(key, cls.__marker__)
-        if value is cls.__marker__:
-            return False
-        return True
-
-    def iter(cls, type, readonly=False):
-        for key in dir(cls):
-            if key.startswith("__"):
-                    continue
-
-            if key.endswith(MUTABLE):
-                key = key[:-len(MUTABLE)]
-
-            if type == "keys":
-                yield key
-
-            try:
-                if readonly:
-                    value = cls.__getreadonly__(key)
-                else:
-                    value = cls[key]
-            except KeyError:
-                continue
-
-            if type == "values":
-                yield value
-            if type == "items":
-                yield (key, value)
-        raise StopIteration()
-
-    def iterkeys(cls):
-        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."
-        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."
-        return cls.iter("items", readonly)
-
-class COWSetMeta(COWDictMeta):
-    def __str__(cls):
-        # FIXME: I have magic numbers!
-        return "<COWSet Level: %i Current Keys: %i>" % (cls.__count__, len(cls.__dict__) -3)
-    __repr__ = __str__
-
-    def cow(cls):
-        class C(cls):
-            __count__ = cls.__count__ + 1
-        return C
-
-    def add(cls, value):
-        COWDictMeta.__setitem__(cls, repr(hash(value)), value)
-
-    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'")
-
-# These are the actual classes you use!
-class COWDictBase(object):
-    __metaclass__ = COWDictMeta
-    __count__ = 0
-
-class COWSetBase(object):
-    __metaclass__ = COWSetMeta
-    __count__ = 0
-
-if __name__ == "__main__":
-    import sys
-    COWDictBase.__warn__ = sys.stderr
-    a = COWDictBase()
-    print "a", a
-
-    a['a'] = 'a'
-    a['b'] = 'b'
-    a['dict'] = {}
-
-    b = a.copy()
-    print "b", b
-    b['c'] = 'b'
-
-    print
-
-    print "a", a
-    for x in a.iteritems():
-        print x
-    print "--"
-    print "b", b
-    for x in b.iteritems():
-        print x
-    print
-
-    b['dict']['a'] = 'b'
-    b['a'] = 'c'
-
-    print "a", a
-    for x in a.iteritems():
-        print x
-    print "--"
-    print "b", b
-    for x in b.iteritems():
-        print x
-    print
-
-    try:
-        b['dict2']
-    except KeyError, e:
-        print "Okay!"
-
-    a['set'] = COWSetBase()
-    a['set'].add("o1")
-    a['set'].add("o1")
-    a['set'].add("o2")
-
-    print "a", a
-    for x in a['set'].itervalues():
-        print x
-    print "--"
-    print "b", b
-    for x in b['set'].itervalues():
-        print x
-    print
-
-    b['set'].add('o3')
-
-    print "a", a
-    for x in a['set'].itervalues():
-        print x
-    print "--"
-    print "b", b
-    for x in b['set'].itervalues():
-        print x
-    print
-
-    a['set2'] = set()
-    a['set2'].add("o1")
-    a['set2'].add("o1")
-    a['set2'].add("o2")
-
-    print "a", a
-    for x in a.iteritems():
-        print x
-    print "--"
-    print "b", b
-    for x in b.iteritems(readonly=True):
-        print x
-    print
-
-    del b['b']
-    try:
-        print b['b']
-    except KeyError:
-        print "Yay! deleted key raises error"
-
-    if b.has_key('b'):
-        print "Boo!"
-    else:
-        print "Yay - has_key with delete works!"
-    
-    print "a", a
-    for x in a.iteritems():
-        print x
-    print "--"
-    print "b", b
-    for x in b.iteritems(readonly=True):
-        print x
-    print
-
-    b.__revertitem__('b')
-
-    print "a", a
-    for x in a.iteritems():
-        print x
-    print "--"
-    print "b", b
-    for x in b.iteritems(readonly=True):
-        print x
-    print
-
-    b.__revertitem__('dict')
-    print "a", a
-    for x in a.iteritems():
-        print x
-    print "--"
-    print "b", b
-    for x in b.iteritems(readonly=True):
-        print x
-    print
--- a/bitbake-dev/lib/bb/init.py
+++ b/bitbake-dev/lib/bb/init.py
--- a/bitbake-dev/lib/bb/build.py
+++ b/bitbake-dev/lib/bb/build.py
@@ -1,394 +0,0 @@
-# ex:ts=4:sw=4:sts=4:et
-# -*- tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*-
-#
-# BitBake 'Build' implementation
-#
-# Core code for function execution and task handling in the
-# BitBake build tools.
-#
-# Copyright (C) 2003, 2004  Chris Larson
-#
-# Based on Gentoo's portage.py.
-#
-# 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
-
-from bb import data, event, mkdirhier, utils
-import bb, os, sys
-
-# 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
-    First parameter a message
-    Second paramter is a logfile (optional)
-    """
-
-class EventException(Exception):
-    """Exception which is associated with an Event."""
-
-    def __init__(self, msg, event):
-        self.args = msg, event
-
-class TaskBase(event.Event):
-    """Base class for task events"""
-
-    def __init__(self, t, d ):
-        self._task = t
-        self._package = bb.data.getVar("PF", d, 1)
-        event.Event.__init__(self, d)
-        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
-
-    def setTask(self, task):
-        self._task = task
-
-    task = property(getTask, setTask, None, "task property")
-
-class TaskStarted(TaskBase):
-    """Task execution started"""
-
-class TaskSucceeded(TaskBase):
-    """Task execution completed"""
-
-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):
-    """Invalid Task"""
-
-# functions
-
-def exec_func(func, d, dirs = None):
-    """Execute an BB 'function'"""
-
-    body = data.getVar(func, d)
-    if not body:
-        return
-
-    flags = data.getVarFlags(func, d)
-    for item in ['deps', 'check', 'interactive', 'python', 'cleandirs', 'dirs', 'lockfiles', 'fakeroot']:
-        if not item in flags:
-            flags[item] = None
-
-    ispython = flags['python']
-
-    cleandirs = (data.expand(flags['cleandirs'], d) or "").split()
-    for cdir in cleandirs:
-        os.system("rm -rf %s" % cdir)
-
-    if dirs:
-        dirs = data.expand(dirs, d)
-    else:
-        dirs = (data.expand(flags['dirs'], d) or "").split()
-    for adir in dirs:
-        mkdirhier(adir)
-
-    if len(dirs) > 0:
-        adir = dirs[-1]
-    else:
-        adir = data.getVar('B', d, 1)
-
-    # Save current directory
-    try:
-        prevdir = os.getcwd()
-    except OSError:
-        prevdir = data.getVar('TOPDIR', d, True)
-
-    # Setup logfiles
-    t = data.getVar('T', d, 1)
-    if not t:
-        bb.msg.fatal(bb.msg.domain.Build, "T not set")
-    mkdirhier(t)
-    # Gross hack, FIXME
-    import random
-    logfile = "%s/log.%s.%s.%s" % (t, func, str(os.getpid()),random.random())
-    runfile = "%s/run.%s.%s" % (t, func, str(os.getpid()))
-
-    # Change to correct directory (if specified)
-    if adir and os.access(adir, os.F_OK):
-        os.chdir(adir)
-
-    # Handle logfiles
-    si = file('/dev/null', 'r')
-    try:
-        if bb.msg.debug_level['default'] > 0 or ispython:
-            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
-
-    # 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])
-
-    locks = []
-    lockfiles = (data.expand(flags['lockfiles'], d) or "").split()
-    for lock in lockfiles:
-        locks.append(bb.utils.lockfile(lock))
-
-    try:
-        # Run the function
-        if ispython:
-            exec_func_python(func, d, runfile, logfile)
-        else:
-            exec_func_shell(func, d, runfile, logfile, flags)
-
-        # Restore original directory
-        try:
-            os.chdir(prevdir)
-        except:
-            pass
-
-    finally:
-
-        # Unlock any lockfiles
-        for lock in locks:
-            bb.utils.unlockfile(lock)
-
-        # 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 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)
-
-        # Close the backup fds
-        os.close(osi[0])
-        os.close(oso[0])
-        os.close(ose[0])
-
-def exec_func_python(func, d, runfile, logfile):
-    """Execute a python BB 'function'"""
-    import re, os
-
-    bbfile = bb.data.getVar('FILE', d, 1)
-    tmp  = "def " + func + "():\n%s" % data.getVar(func, d)
-    tmp += '\n' + func + '()'
-
-    f = open(runfile, "w")
-    f.write(tmp)
-    comp = utils.better_compile(tmp, func, bbfile)
-    g = {} # globals
-    g['d'] = d
-    try:
-        utils.better_exec(comp, g, tmp, bbfile)
-    except:
-        (t,value,tb) = sys.exc_info()
-
-        if t in [bb.parse.SkipPackage, bb.build.FuncFailed]:
-            raise
-        bb.msg.error(bb.msg.domain.Build, "Function %s failed" % func)
-        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
-    data into it and finally executes. The output of the shell will end in a log file and stdout.
-
-    Note on directory behavior.  The 'dirs' varflag should contain a list
-    of the directories you need created prior to execution.  The last
-    item in the list is where we will chdir/cd to.
-    """
-
-    deps = flags['deps']
-    check = flags['check']
-    if check in globals():
-        if globals()[check](func, deps):
-            return
-
-    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)
-
-    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("Function not specified for exec_func_shell")
-
-    # execute function
-    if flags['fakeroot']:
-        maybe_fakeroot = "PATH=\"%s\" fakeroot " % bb.data.getVar("PATH", d, 1)
-    else:
-        maybe_fakeroot = ''
-    lang_environment = "LC_ALL=C "
-    ret = os.system('%s%ssh -e %s' % (lang_environment, maybe_fakeroot, runfile))
-
-    if ret == 0:
-        return
-
-    bb.msg.error(bb.msg.domain.Build, "Function %s failed" % func)
-    raise FuncFailed("function %s failed" % func, logfile)
-
-
-def exec_task(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 whther this is a valid task
-    if not data.getVarFlag(task, 'task', d):
-        raise EventException("No such task", InvalidTask(task, d))
-
-    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)
-        event.fire(TaskStarted(task, localdata))
-        exec_func(task, localdata)
-        event.fire(TaskSucceeded(task, localdata))
-    except FuncFailed, message:
-        # Try to extract the optional logfile
-        try:
-            (msg, logfile) = message
-        except:
-            logfile = None
-            msg = message
-        bb.msg.note(1, bb.msg.domain.Build, "Task failed: %s" % message )
-        failedevent = TaskFailed(msg, logfile, task, d)
-        event.fire(failedevent)
-        raise EventException("Function failed in task: %s" % message, failedevent)
-
-    # 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)
-
-def extract_stamp(d, fn):
-    """
-    Extracts stamp format which is either a data dictonary (fn unset) 
-    or a dataCache entry (fn set). 
-    """
-    if fn:
-        return d.stamp[fn]
-    return data.getVar('STAMP', d, 1)
-
-def stamp_internal(task, d, file_name):
-    """
-    Internal stamp helper function
-    Removes any stamp for the given task
-    Makes sure the stamp directory exists
-    Returns the stamp path+filename
-    """
-    stamp = extract_stamp(d, file_name)
-    if not stamp:
-        return
-    stamp = "%s.%s" % (stamp, task)
-    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):
-        os.remove(stamp)
-    return stamp
-
-def make_stamp(task, d, file_name = None):
-    """
-    Creates/updates a stamp for a given task
-    (d can be a data dict or dataCache)
-    """
-    stamp = stamp_internal(task, d, file_name)
-    if stamp:
-        f = open(stamp, "w")
-        f.close()
-
-def del_stamp(task, d, file_name = None):
-    """
-    Removes a stamp for a given task
-    (d can be a data dict or dataCache)
-    """
-    stamp_internal(task, d, file_name)
-
-def add_tasks(tasklist, d):
-    task_deps = data.getVar('_task_deps', d)
-    if not task_deps:
-        task_deps = {}
-    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] = {}
-            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')
-        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):
-    """Remove an BB 'task'.
-
-       If kill is 1, also remove tasks that depend on this task."""
-
-    data.delVarFlag(task, 'task', d)
-
--- a/bitbake-dev/lib/bb/cache.py
+++ b/bitbake-dev/lib/bb/cache.py
@@ -1,534 +0,0 @@
-# ex:ts=4:sw=4:sts=4:et
-# -*- tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*-
-#
-# BitBake 'Event' implementation
-#
-# Caching of bitbake variables before task execution
-
-# Copyright (C) 2006        Richard Purdie
-
-# but small sections based on code from bin/bitbake:
-# Copyright (C) 2003, 2004  Chris Larson
-# Copyright (C) 2003, 2004  Phil Blundell
-# Copyright (C) 2003 - 2005 Michael 'Mickey' Lauer
-# Copyright (C) 2005        Holger Hans Peter Freyther
-# Copyright (C) 2005        ROAD GmbH
-#
-# 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, re
-import bb.data
-import bb.utils
-
-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.")
-
-__cache_version__ = "130"
-
-class Cache:
-    """
-    BitBake Cache implementation
-    """
-    def __init__(self, cooker):
-
-
-        self.cachedir = bb.data.getVar("CACHE", cooker.configuration.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.")
-            return
-
-        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 )
-
-        # 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", cooker.configuration.data, True)
-        for f,old_mtime in deps:
-            if old_mtime > newest_mtime:
-                newest_mtime = old_mtime
-
-        if bb.parse.cached_mtime_noerror(self.cachefile) >= newest_mtime:
-            try:
-                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'
-                if version_data['BITBAKE_VER'] != bb.__version__:
-                    raise ValueError, 'Bitbake Version Mismatch'
-            except EOFError:
-                bb.msg.note(1, bb.msg.domain.Cache, "Truncated cache found, rebuilding...")
-                self.depends_cache = {}
-            except:
-                bb.msg.note(1, bb.msg.domain.Cache, "Invalid cache found, rebuilding...")
-                self.depends_cache = {}
-        else:
-            try:
-                os.stat( self.cachefile )
-                bb.msg.note(1, bb.msg.domain.Cache, "Out of date cache found, rebuilding...")
-            except OSError:
-                pass
-
-    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 
-             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] = {}
-
-        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, 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 = virtualfn
-        self.data = data
-
-        # Make sure __depends makes the depends_cache
-        self.getVar("__depends", 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, cfgData):
-        """
-        Return a complete set of data for fn.
-        To do this, we need to parse the file.
-        """
-
-        (fn, cls) = self.virtualfn2realfn(virtualfn)
-
-        bb.msg.debug(1, bb.msg.domain.Cache, "Parsing %s (full)" % fn)
-
-        bb_data, skipped = self.load_bbfile(fn, cfgData)
-        if isinstance(bb_data, dict):
-            return bb_data[cls]
-
-        return bb_data
-
-    def loadData(self, fn, cfgData, cacheData):
-        """
-        Load a subset of data for fn.
-        If the cached data is valid we do nothing,
-        To do this, we need to parse the file and set the system
-        to record the variables accessed.
-        Return the cache status and whether the file was skipped when parsed
-        """
-        if fn not in self.checked:
-            self.cacheValidUpdate(fn)
-        if self.cacheValid(fn):
-            if "SKIPPED" in self.depends_cache[fn]:
-                return True, True
-            self.handle_data(fn, cacheData)
-            multi = self.getVar('BBCLASSEXTEND', fn, True)
-            if multi:
-                for cls in multi.split():
-                    virtualfn = self.realfn2virtual(fn, cls)
-                    # Pretend we're clean so getVar works
-                    self.clean[virtualfn] = ""
-                    self.handle_data(virtualfn, cacheData)
-            return True, False
-
-        bb.msg.debug(1, bb.msg.domain.Cache, "Parsing %s" % fn)
-
-        bb_data, skipped = self.load_bbfile(fn, cfgData)
-
-        if skipped:
-           if isinstance(bb_data, dict):
-               self.setData(fn, fn, bb_data[""])
-           else:
-               self.setData(fn, fn, bb_data)
-           return False, skipped
-
-        if isinstance(bb_data, dict):
-            for data in bb_data:
-                virtualfn = self.realfn2virtual(fn, data)
-                self.setData(virtualfn, fn, bb_data[data])
-                self.handle_data(virtualfn, cacheData)
-            return False, skipped
-
-        self.setData(fn, fn, bb_data)
-        self.handle_data(fn, cacheData)
-        return False, skipped
-
-    def cacheValid(self, fn):
-        """
-        Is the cache valid for fn?
-        Fast version, no timestamps checked.
-        """
-        # Is cache enabled?
-        if not self.has_cache:
-            return False
-        if fn in self.clean:
-            return True
-        return False
-
-    def cacheValidUpdate(self, fn):
-        """
-        Is the cache valid for fn?
-        Make thorough (slower) checks including timestamps.
-        """
-        # Is cache enabled?
-        if not self.has_cache:
-            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:
-            bb.msg.debug(2, bb.msg.domain.Cache, "Cache: %s is not cached" % fn)
-            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 not longer exists" % fn)
-            self.remove(fn)
-            return False
-
-        # Check the file's timestamp
-        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)
-        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
-
-                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)
-        if not fn in self.clean:
-            self.clean[fn] = ""
-
-        return 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"
-
-    def remove(self, fn):
-        """
-        Remove a fn from the cache
-        Called from the parser in error cases
-        """
-        bb.msg.debug(1, bb.msg.domain.Cache, "Removing %s from cache" % fn)
-        if fn in self.depends_cache:
-            del self.depends_cache[fn]
-        if fn in self.clean:
-            del self.clean[fn]
-
-    def sync(self):
-        """
-        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.deepcopy(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([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 
-        """
-
-        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.note("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")
-        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_deps[file_name] = self.getVar("_task_deps", file_name, True)
-
-        # build PackageName to FileName lookup table
-        if pn not in cacheData.pkg_pn:
-            cacheData.pkg_pn[pn] = []
-        cacheData.pkg_pn[pn].append(file_name)
-
-        cacheData.stamp[file_name] = self.getVar('STAMP', 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_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] = []
-
-        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] = []
-        for dep in depends:
-            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 
-        # 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() 
-
-        for package in packages_dynamic:
-            if not package in cacheData.packages_dynamic:
-                cacheData.packages_dynamic[package] = []
-            cacheData.packages_dynamic[package].append(file_name)
-
-        for rprovide in rprovides:
-            if not rprovide in cacheData.rproviders:
-                cacheData.rproviders[rprovide] = []
-            cacheData.rproviders[rprovide].append(file_name)
-
-        # Build hash of runtime depends and rececommends
-
-        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] = []
-            if not package in cacheData.runrecs[file_name]:
-                cacheData.runrecs[file_name][package] = []
-
-            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)
-
-        # Touch this to make sure its in the cache
-        self.getVar('__BB_DONT_CACHE', file_name, True)
-        self.getVar('BBCLASSEXTEND', file_name, True)
-
-    def load_bbfile( self, bbfile , config):
-        """
-        Load and parse one .bb build file
-        Return the data and whether parsing resulted in the file being skipped
-        """
-
-        import bb
-        from bb import utils, data, parse, debug, event, fatal
-
-        # 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 bb.parse.cached_mtime_noerror(bbfile_loc):
-            os.chdir(bbfile_loc)
-        bb_data = data.init_db(config)
-        try:
-            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
-        except:
-            os.chdir(oldpath)
-            raise
-
-def init(cooker):
-    """
-    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 
-    file we need to track:
-
-    * Its mtime
-    * The mtimes of all its dependencies
-    * Whether it caused a parse.SkipPackage exception
-
-    Files causing parsing errors are evicted from the cache.
-
-    """
-    return Cache(cooker)
-
-
-
-#============================================================================#
-# CacheData
-#============================================================================#
-class CacheData:
-    """
-    The data structures we compile from the cached data
-    """
-
-    def __init__(self):
-        """
-        Direct cache variables
-        (from Cache.handle_data)
-        """
-        self.providers   = {}
-        self.rproviders = {}
-        self.packages = {}
-        self.packages_dynamic = {}
-        self.possible_world = []
-        self.pkg_pn = {}
-        self.pkg_fn = {}
-        self.pkg_pepvpr = {}
-        self.pkg_dp = {}
-        self.pn_provides = {}
-        self.fn_provides = {}
-        self.all_depends = []
-        self.deps = {}
-        self.rundeps = {}
-        self.runrecs = {}
-        self.task_queues = {}
-        self.task_deps = {}
-        self.stamp = {}
-        self.preferred = {}
-
-        """
-        Indirect Cache variables
-        (set elsewhere)
-        """
-        self.ignored_dependencies = []
-        self.world_target = set()
-        self.bbfile_priority = {}
-        self.bbfile_config_priorities = []
--- a/bitbake-dev/lib/bb/command.py
+++ b/bitbake-dev/lib/bb/command.py
@@ -1,272 +0,0 @@
-"""
-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
-
-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):
-        bb.debug("Running command %s" % 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:
-            import traceback
-            self.finishAsyncCommand(traceback.format_exc())
-            return False
-
-    def finishAsyncCommand(self, error = None):
-        if error:
-            bb.event.fire(bb.command.CookerCommandFailed(self.cooker.configuration.event_data, error))
-        else:
-            bb.event.fire(bb.command.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, data):
-        bb.event.Event.__init__(self, data)
-
-
-class CookerCommandFailed(bb.event.Event):
-    """
-    Cooker command completed
-    """
-    def  __init__(self, data, error):
-        bb.event.Event.__init__(self, data)
-        self.error = error
-
-class CookerCommandSetExitCode(bb.event.Event):
-    """
-    Set the exit code for a cooker command
-    """
-    def  __init__(self, data, exitcode):
-        bb.event.Event.__init__(self, data)
-        self.exitcode = int(exitcode)
-
-
-
--- a/bitbake-dev/lib/bb/cooker.py
+++ b/bitbake-dev/lib/bb/cooker.py
@@ -1,977 +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, 2004  Chris Larson
-# Copyright (C) 2003, 2004  Phil Blundell
-# Copyright (C) 2003 - 2005 Michael 'Mickey' Lauer
-# Copyright (C) 2005        Holger Hans Peter Freyther
-# Copyright (C) 2005        ROAD GmbH
-# 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.
-
-import sys, os, getopt, glob, copy, os.path, re, time
-import bb
-from bb import utils, data, parse, event, cache, providers, taskdata, runqueue
-from bb import xmlrpcserver, command
-import itertools, sre_constants
-
-class MultipleMatches(Exception):
-    """
-    Exception raised when multiple file matches are found
-    """
-
-class ParsingErrorsFound(Exception):
-    """
-    Exception raised when parsing errors are found
-    """
-
-class NothingToBuild(Exception):
-    """
-    Exception raised when there is nothing to build
-    """
-
-
-# Different states cooker can be in
-cookerClean = 1
-cookerParsing = 2
-cookerParsed = 3
-
-# Different action states the cooker can be in
-cookerRun = 1           # Cooker is running normally
-cookerShutdown = 2      # Active tasks should be brought to a controlled stop
-cookerStop = 3          # Stop, now!
-
-#============================================================================#
-# BBCooker
-#============================================================================#
-class BBCooker:
-    """
-    Manages one bitbake build run
-    """
-
-    def __init__(self, configuration):
-        self.status = None
-
-        self.cache = None
-        self.bb_cache = None
-
-        self.server = bb.xmlrpcserver.BitBakeXMLRPCServer(self)
-        #self.server.register_function(self.showEnvironment)
-
-        self.configuration = configuration
-
-        if self.configuration.verbose:
-            bb.msg.set_verbose(True)
-
-        if self.configuration.debug:
-            bb.msg.set_debug_level(self.configuration.debug)
-        else:
-            bb.msg.set_debug_level(0)
-
-        if self.configuration.debug_domains:
-            bb.msg.set_debug_domains(self.configuration.debug_domains)
-
-        self.configuration.data = bb.data.init()
-
-        bb.data.inheritFromOS(self.configuration.data)
-
-        for f in self.configuration.file:
-            self.parseConfigurationFile( f )
-
-        self.parseConfigurationFile( os.path.join( "conf", "bitbake.conf" ) )
-
-        if not self.configuration.cmd:
-            self.configuration.cmd = bb.data.getVar("BB_DEFAULT_TASK", self.configuration.data, True) or "build"
-
-        bbpkgs = bb.data.getVar('BBPKGS', self.configuration.data, True)
-        if bbpkgs and len(self.configuration.pkgs_to_build) == 0:
-            self.configuration.pkgs_to_build.extend(bbpkgs.split())
-
-        #
-        # Special updated configuration we use for firing events
-        #
-        self.configuration.event_data = bb.data.createCopy(self.configuration.data)
-        bb.data.update_data(self.configuration.event_data)
-
-        # TOSTOP must not be set or our children will hang when they output
-        fd = sys.stdout.fileno()
-        if os.isatty(fd):
-            import termios
-            tcattr = termios.tcgetattr(fd)
-            if tcattr[3] & termios.TOSTOP:
-                bb.msg.note(1, bb.msg.domain.Build, "The terminal had the TOSTOP bit set, clearing...")
-                tcattr[3] = tcattr[3] & ~termios.TOSTOP
-                termios.tcsetattr(fd, termios.TCSANOW, tcattr)
-
-        self.command = bb.command.Command(self)
-        self.cookerState = cookerClean
-        self.cookerAction = cookerRun
-
-    def parseConfiguration(self):
-
-
-        # Change nice level if we're asked to
-        nice = bb.data.getVar("BB_NICE_LEVEL", self.configuration.data, True)
-        if nice:
-            curnice = os.nice(0)
-            nice = int(nice) - curnice
-            bb.msg.note(2, bb.msg.domain.Build, "Renice to %s " % os.nice(nice))
-
-    def parseCommandLine(self):
-        # Parse any commandline into actions
-        if self.configuration.show_environment:
-            self.commandlineAction = None
-
-            if 'world' in self.configuration.pkgs_to_build:
-                bb.error("'world' is not a valid target for --environment.")
-            elif len(self.configuration.pkgs_to_build) > 1:
-                bb.error("Only one target can be used with the --environment option.")
-            elif self.configuration.buildfile and len(self.configuration.pkgs_to_build) > 0:
-                bb.error("No target should be used with the --environment and --buildfile options.")
-            elif len(self.configuration.pkgs_to_build) > 0:
-                self.commandlineAction = ["showEnvironmentTarget", self.configuration.pkgs_to_build]
-            else:
-                self.commandlineAction = ["showEnvironment", self.configuration.buildfile]
-        elif self.configuration.buildfile is not None:
-            self.commandlineAction = ["buildFile", self.configuration.buildfile, self.configuration.cmd]
-        elif self.configuration.revisions_changed:
-            self.commandlineAction = ["compareRevisions"]
-        elif self.configuration.show_versions:
-            self.commandlineAction = ["showVersions"]
-        elif self.configuration.parse_only:
-            self.commandlineAction = ["parseFiles"]
-        # FIXME - implement
-        #elif self.configuration.interactive:
-        #    self.interactiveMode()
-        elif self.configuration.dot_graph:
-            if self.configuration.pkgs_to_build:
-                self.commandlineAction = ["generateDotGraph", self.configuration.pkgs_to_build, self.configuration.cmd]
-            else:
-                self.commandlineAction = None
-                bb.error("Please specify a package name for dependency graph generation.")
-        else:
-            if self.configuration.pkgs_to_build:
-                self.commandlineAction = ["buildTargets", self.configuration.pkgs_to_build, self.configuration.cmd]
-            else:
-                self.commandlineAction = None
-                bb.error("Nothing to do.  Use 'bitbake world' to build everything, or run 'bitbake --help' for usage information.")
-
-    def runCommands(self, server, data, abort):
-        """
-        Run any queued asynchronous command
-        This is done by the idle handler so it runs in true context rather than
-        tied to any UI.
-        """
-
-        return self.command.runAsyncCommand()
-
-    def tryBuildPackage(self, fn, item, task, the_data):
-        """
-        Build one task of a package, optionally build following task depends
-        """
-        try:
-            if not self.configuration.dry_run:
-                bb.build.exec_task('do_%s' % task, the_data)
-            return True
-        except bb.build.FuncFailed:
-            bb.msg.error(bb.msg.domain.Build, "task stack execution failed")
-            raise
-        except bb.build.EventException, e:
-            event = e.args[1]
-            bb.msg.error(bb.msg.domain.Build, "%s event exception, aborting" % bb.event.getName(event))
-            raise
-
-    def tryBuild(self, fn, task):
-        """
-        Build a provider and its dependencies. 
-        build_depends is a list of previous build dependencies (not runtime)
-        If build_depends is empty, we're dealing with a runtime depends
-        """
-
-        the_data = self.bb_cache.loadDataFull(fn, self.configuration.data)
-
-        item = self.status.pkg_fn[fn]
-
-        #if bb.build.stamp_is_current('do_%s' % self.configuration.cmd, the_data):
-        #    return True
-
-        return self.tryBuildPackage(fn, item, task, the_data)
-
-    def showVersions(self):
-
-        # Need files parsed
-        self.updateCache()
-
-        pkg_pn = self.status.pkg_pn
-        preferred_versions = {}
-        latest_versions = {}
-
-        # Sort by priority
-        for pn in pkg_pn.keys():
-            (last_ver,last_file,pref_ver,pref_file) = bb.providers.findBestProvider(pn, self.configuration.data, self.status)
-            preferred_versions[pn] = (pref_ver, pref_file)
-            latest_versions[pn] = (last_ver, last_file)
-
-        pkg_list = pkg_pn.keys()
-        pkg_list.sort()
-
-        bb.msg.plain("%-35s %25s %25s" % ("Package Name", "Latest Version", "Preferred Version"))
-        bb.msg.plain("%-35s %25s %25s\n" % ("============", "==============", "================="))
-
-        for p in pkg_list:
-            pref = preferred_versions[p]
-            latest = latest_versions[p]
-
-            prefstr = pref[0][0] + ":" + pref[0][1] + '-' + pref[0][2]
-            lateststr = latest[0][0] + ":" + latest[0][1] + "-" + latest[0][2]
-
-            if pref == latest:
-                prefstr = ""
-
-            bb.msg.plain("%-35s %25s %25s" % (p, lateststr, prefstr))
-
-    def compareRevisions(self):
-        ret = bb.fetch.fetcher_compare_revisons(self.configuration.data)
-        bb.event.fire(bb.command.CookerCommandSetExitCode(self.configuration.event_data, ret))
-
-    def showEnvironment(self, buildfile = None, pkgs_to_build = []):
-        """
-        Show the outer or per-package environment
-        """
-        fn = None
-        envdata = None
-
-        if buildfile:
-            self.cb = None
-            self.bb_cache = bb.cache.init(self)
-            fn = self.matchFile(buildfile)
-        elif len(pkgs_to_build) == 1:
-            self.updateCache()
-
-            localdata = data.createCopy(self.configuration.data)
-            bb.data.update_data(localdata)
-            bb.data.expandKeys(localdata)
-
-            taskdata = bb.taskdata.TaskData(self.configuration.abort)
-            taskdata.add_provider(localdata, self.status, pkgs_to_build[0])
-            taskdata.add_unresolved(localdata, self.status)
-
-            targetid = taskdata.getbuild_id(pkgs_to_build[0])
-            fnid = taskdata.build_targets[targetid][0]
-            fn = taskdata.fn_index[fnid]
-        else:
-            envdata = self.configuration.data
-
-        if fn:
-            try:
-                envdata = self.bb_cache.loadDataFull(fn, self.configuration.data)
-            except IOError, e:
-                bb.msg.error(bb.msg.domain.Parsing, "Unable to read %s: %s" % (fn, e))
-                raise
-            except Exception, e:
-                bb.msg.error(bb.msg.domain.Parsing, "%s" % e)
-                raise
-
-        class dummywrite:
-            def __init__(self):
-                self.writebuf = ""
-            def write(self, output):
-                self.writebuf = self.writebuf + output
-
-        # emit variables and shell functions
-        try:
-            data.update_data(envdata)
-            wb = dummywrite()
-            data.emit_env(wb, envdata, True)
-            bb.msg.plain(wb.writebuf)
-        except Exception, e:
-            bb.msg.fatal(bb.msg.domain.Parsing, "%s" % e)
-        # emit the metadata which isnt valid shell
-        data.expandKeys(envdata)
-        for e in envdata.keys():
-            if data.getVarFlag( e, 'python', envdata ):
-                bb.msg.plain("\npython %s () {\n%s}\n" % (e, data.getVar(e, envdata, 1)))
-
-    def generateDepTreeData(self, pkgs_to_build, task):
-        """
-        Create a dependency tree of pkgs_to_build, returning the data.
-        """
-
-        # Need files parsed
-        self.updateCache()
-
-        # If we are told to do the None task then query the default task
-        if (task == None):
-            task = self.configuration.cmd
-
-        pkgs_to_build = self.checkPackages(pkgs_to_build)
-
-        localdata = data.createCopy(self.configuration.data)
-        bb.data.update_data(localdata)
-        bb.data.expandKeys(localdata)
-        taskdata = bb.taskdata.TaskData(self.configuration.abort)
-
-        runlist = []
-        for k in pkgs_to_build:
-            taskdata.add_provider(localdata, self.status, k)
-            runlist.append([k, "do_%s" % task])
-        taskdata.add_unresolved(localdata, self.status)
-
-        rq = bb.runqueue.RunQueue(self, self.configuration.data, self.status, taskdata, runlist)
-        rq.prepare_runqueue()
-
-        seen_fnids = []  
-        depend_tree = {}
-        depend_tree["depends"] = {}
-        depend_tree["tdepends"] = {}
-        depend_tree["pn"] = {}
-        depend_tree["rdepends-pn"] = {}
-        depend_tree["packages"] = {}
-        depend_tree["rdepends-pkg"] = {}
-        depend_tree["rrecs-pkg"] = {}
-
-        for task in range(len(rq.runq_fnid)):
-            taskname = rq.runq_task[task]
-            fnid = rq.runq_fnid[task]
-            fn = taskdata.fn_index[fnid]
-            pn = self.status.pkg_fn[fn]
-            version  = "%s:%s-%s" % self.status.pkg_pepvpr[fn]
-            if pn not in depend_tree["pn"]:
-                depend_tree["pn"][pn] = {}
-                depend_tree["pn"][pn]["filename"] = fn
-                depend_tree["pn"][pn]["version"] = version
-            for dep in rq.runq_depends[task]:
-                depfn = taskdata.fn_index[rq.runq_fnid[dep]]
-                deppn = self.status.pkg_fn[depfn]
-                dotname = "%s.%s" % (pn, rq.runq_task[task])
-                if not dotname in depend_tree["tdepends"]:
-                    depend_tree["tdepends"][dotname] = []
-                depend_tree["tdepends"][dotname].append("%s.%s" % (deppn, rq.runq_task[dep]))
-            if fnid not in seen_fnids:
-                seen_fnids.append(fnid)
-                packages = []
-
-                depend_tree["depends"][pn] = []
-                for dep in taskdata.depids[fnid]:
-                    depend_tree["depends"][pn].append(taskdata.build_names_index[dep])
-
-                depend_tree["rdepends-pn"][pn] = []
-                for rdep in taskdata.rdepids[fnid]:
-                        depend_tree["rdepends-pn"][pn].append(taskdata.run_names_index[rdep])
-
-                rdepends = self.status.rundeps[fn]
-                for package in rdepends:
-                    depend_tree["rdepends-pkg"][package] = []
-                    for rdepend in rdepends[package]:
-                        depend_tree["rdepends-pkg"][package].append(rdepend)
-                    packages.append(package)
-
-                rrecs = self.status.runrecs[fn]
-                for package in rrecs:
-                    depend_tree["rrecs-pkg"][package] = []
-                    for rdepend in rrecs[package]:
-                        depend_tree["rrecs-pkg"][package].append(rdepend)
-                    if not package in packages:
-                        packages.append(package)
-
-                for package in packages:
-                    if package not in depend_tree["packages"]:
-                        depend_tree["packages"][package] = {}
-                        depend_tree["packages"][package]["pn"] = pn
-                        depend_tree["packages"][package]["filename"] = fn
-                        depend_tree["packages"][package]["version"] = version
-
-        return depend_tree
-
-
-    def generateDepTreeEvent(self, pkgs_to_build, task):
-        """
-        Create a task dependency graph of pkgs_to_build.
-        Generate an event with the result
-        """
-        depgraph = self.generateDepTreeData(pkgs_to_build, task)
-        bb.event.fire(bb.event.DepTreeGenerated(self.configuration.data, depgraph))
-
-    def generateDotGraphFiles(self, pkgs_to_build, task):
-        """
-        Create a task dependency graph of pkgs_to_build.
-        Save the result to a set of .dot files.
-        """
-
-        depgraph = self.generateDepTreeData(pkgs_to_build, task)
-
-        # Prints a flattened form of package-depends below where subpackages of a package are merged into the main pn
-        depends_file = file('pn-depends.dot', 'w' )
-        print >> depends_file, "digraph depends {"
-        for pn in depgraph["pn"]:
-            fn = depgraph["pn"][pn]["filename"]
-            version = depgraph["pn"][pn]["version"]
-            print >> depends_file, '"%s" [label="%s %s\\n%s"]' % (pn, pn, version, fn)
-        for pn in depgraph["depends"]:
-            for depend in depgraph["depends"][pn]:
-                print >> depends_file, '"%s" -> "%s"' % (pn, depend)
-        for pn in depgraph["rdepends-pn"]:
-            for rdepend in depgraph["rdepends-pn"][pn]:
-                print >> depends_file, '"%s" -> "%s" [style=dashed]' % (pn, rdepend)
-        print >> depends_file,  "}"
-        bb.msg.plain("PN dependencies saved to 'pn-depends.dot'")
-
-        depends_file = file('package-depends.dot', 'w' )
-        print >> depends_file, "digraph depends {"
-        for package in depgraph["packages"]:
-            pn = depgraph["packages"][package]["pn"]
-            fn = depgraph["packages"][package]["filename"]
-            version = depgraph["packages"][package]["version"]
-            if package == pn:
-                print >> depends_file, '"%s" [label="%s %s\\n%s"]' % (pn, pn, version, fn)
-            else:
-                print >> depends_file, '"%s" [label="%s(%s) %s\\n%s"]' % (package, package, pn, version, fn)
-            for depend in depgraph["depends"][pn]:
-                print >> depends_file, '"%s" -> "%s"' % (package, depend)
-        for package in depgraph["rdepends-pkg"]:
-            for rdepend in depgraph["rdepends-pkg"][package]:
-                print >> depends_file, '"%s" -> "%s" [style=dashed]' % (package, rdepend)
-        for package in depgraph["rrecs-pkg"]:
-            for rdepend in depgraph["rrecs-pkg"][package]:
-                print >> depends_file, '"%s" -> "%s" [style=dashed]' % (package, rdepend)
-        print >> depends_file,  "}"
-        bb.msg.plain("Package dependencies saved to 'package-depends.dot'")
-
-        tdepends_file = file('task-depends.dot', 'w' )
-        print >> tdepends_file, "digraph depends {"
-        for task in depgraph["tdepends"]:
-            (pn, taskname) = task.rsplit(".", 1)
-            fn = depgraph["pn"][pn]["filename"]
-            version = depgraph["pn"][pn]["version"]
-            print >> tdepends_file, '"%s.%s" [label="%s %s\\n%s\\n%s"]' % (pn, taskname, pn, taskname, version, fn)
-            for dep in depgraph["tdepends"][task]:
-                print >> tdepends_file, '"%s" -> "%s"' % (task, dep)
-        print >> tdepends_file,  "}"
-        bb.msg.plain("Task dependencies saved to 'task-depends.dot'")
-
-    def buildDepgraph( self ):
-        all_depends = self.status.all_depends
-        pn_provides = self.status.pn_provides
-
-        localdata = data.createCopy(self.configuration.data)
-        bb.data.update_data(localdata)
-        bb.data.expandKeys(localdata)
-
-        def calc_bbfile_priority(filename):
-            for (regex, pri) in self.status.bbfile_config_priorities:
-                if regex.match(filename):
-                    return pri
-            return 0
-
-        # Handle PREFERRED_PROVIDERS
-        for p in (bb.data.getVar('PREFERRED_PROVIDERS', localdata, 1) or "").split():
-            try:
-                (providee, provider) = p.split(':')
-            except:
-                bb.msg.fatal(bb.msg.domain.Provider, "Malformed option in PREFERRED_PROVIDERS variable: %s" % p)
-                continue
-            if providee in self.status.preferred and self.status.preferred[providee] != provider:
-                bb.msg.error(bb.msg.domain.Provider, "conflicting preferences for %s: both %s and %s specified" % (providee, provider, self.status.preferred[providee]))
-            self.status.preferred[providee] = provider
-
-        # Calculate priorities for each file
-        for p in self.status.pkg_fn.keys():
-            self.status.bbfile_priority[p] = calc_bbfile_priority(p)
-
-    def buildWorldTargetList(self):
-        """
-         Build package list for "bitbake world"
-        """
-        all_depends = self.status.all_depends
-        pn_provides = self.status.pn_provides
-        bb.msg.debug(1, bb.msg.domain.Parsing, "collating packages for \"world\"")
-        for f in self.status.possible_world:
-            terminal = True
-            pn = self.status.pkg_fn[f]
-
-            for p in pn_provides[pn]:
-                if p.startswith('virtual/'):
-                    bb.msg.debug(2, bb.msg.domain.Parsing, "World build skipping %s due to %s provider starting with virtual/" % (f, p))
-                    terminal = False
-                    break
-                for pf in self.status.providers[p]:
-                    if self.status.pkg_fn[pf] != pn:
-                        bb.msg.debug(2, bb.msg.domain.Parsing, "World build skipping %s due to both us and %s providing %s" % (f, pf, p))
-                        terminal = False
-                        break
-            if terminal:
-                self.status.world_target.add(pn)
-
-            # drop reference count now
-            self.status.possible_world = None
-            self.status.all_depends    = None
-
-    def interactiveMode( self ):
-        """Drop off into a shell"""
-        try:
-            from bb import shell
-        except ImportError, details:
-            bb.msg.fatal(bb.msg.domain.Parsing, "Sorry, shell not available (%s)" % details )
-        else:
-            shell.start( self )
-
-    def parseConfigurationFile( self, afile ):
-        try:
-            self.configuration.data = bb.parse.handle( afile, self.configuration.data )
-
-            # Handle any INHERITs and inherit the base class
-            inherits  = ["base"] + (bb.data.getVar('INHERIT', self.configuration.data, True ) or "").split()
-            for inherit in inherits:
-                self.configuration.data = bb.parse.handle(os.path.join('classes', '%s.bbclass' % inherit), self.configuration.data, True )
-
-            # Nomally we only register event handlers at the end of parsing .bb files
-            # We register any handlers we've found so far here...
-            for var in data.getVar('__BBHANDLERS', self.configuration.data) or []:
-                bb.event.register(var,bb.data.getVar(var, self.configuration.data))
-
-            bb.fetch.fetcher_init(self.configuration.data)
-
-            bb.event.fire(bb.event.ConfigParsed(self.configuration.data))
-
-        except IOError, e:
-            bb.msg.fatal(bb.msg.domain.Parsing, "Error when parsing %s: %s" % (afile, str(e)))
-        except bb.parse.ParseError, details:
-            bb.msg.fatal(bb.msg.domain.Parsing, "Unable to parse %s (%s)" % (afile, details) )
-
-    def handleCollections( self, collections ):
-        """Handle collections"""
-        if collections:
-            collection_list = collections.split()
-            for c in collection_list:
-                regex = bb.data.getVar("BBFILE_PATTERN_%s" % c, self.configuration.data, 1)
-                if regex == None:
-                    bb.msg.error(bb.msg.domain.Parsing, "BBFILE_PATTERN_%s not defined" % c)
-                    continue
-                priority = bb.data.getVar("BBFILE_PRIORITY_%s" % c, self.configuration.data, 1)
-                if priority == None:
-                    bb.msg.error(bb.msg.domain.Parsing, "BBFILE_PRIORITY_%s not defined" % c)
-                    continue
-                try:
-                    cre = re.compile(regex)
-                except re.error:
-                    bb.msg.error(bb.msg.domain.Parsing, "BBFILE_PATTERN_%s \"%s\" is not a valid regular expression" % (c, regex))
-                    continue
-                try:
-                    pri = int(priority)
-                    self.status.bbfile_config_priorities.append((cre, pri))
-                except ValueError:
-                    bb.msg.error(bb.msg.domain.Parsing, "invalid value for BBFILE_PRIORITY_%s: \"%s\"" % (c, priority))
-
-    def buildSetVars(self):
-        """
-        Setup any variables needed before starting a build
-        """
-        if not bb.data.getVar("BUILDNAME", self.configuration.data):
-            bb.data.setVar("BUILDNAME", os.popen('date +%Y%m%d%H%M').readline().strip(), self.configuration.data)
-        bb.data.setVar("BUILDSTART", time.strftime('%m/%d/%Y %H:%M:%S',time.gmtime()), self.configuration.data)
-
-    def matchFiles(self, buildfile):
-        """
-        Find the .bb files which match the expression in 'buildfile'.
-        """
-
-        bf = os.path.abspath(buildfile)
-        try:
-            os.stat(bf)
-            return [bf]
-        except OSError:
-            (filelist, masked) = self.collect_bbfiles()
-            regexp = re.compile(buildfile)
-            matches = []
-            for f in filelist:
-                if regexp.search(f) and os.path.isfile(f):
-                    bf = f
-                    matches.append(f)
-            return matches
-
-    def matchFile(self, buildfile):
-        """
-        Find the .bb file which matches the expression in 'buildfile'.
-        Raise an error if multiple files
-        """
-        matches = self.matchFiles(buildfile)
-        if len(matches) != 1:
-            bb.msg.error(bb.msg.domain.Parsing, "Unable to match %s (%s matches found):" % (buildfile, len(matches)))
-            for f in matches:
-                bb.msg.error(bb.msg.domain.Parsing, "    %s" % f)
-            raise MultipleMatches
-        return matches[0]
-
-    def buildFile(self, buildfile, task):
-        """
-        Build the file matching regexp buildfile
-        """
-
-        # Parse the configuration here. We need to do it explicitly here since
-        # buildFile() doesn't use the cache
-        self.parseConfiguration()
-
-        # If we are told to do the None task then query the default task
-        if (task == None):
-            task = self.configuration.cmd
-
-        fn = self.matchFile(buildfile)
-        self.buildSetVars()
-
-        # Load data into the cache for fn and parse the loaded cache data
-        self.bb_cache = bb.cache.init(self)
-        self.status = bb.cache.CacheData()
-        self.bb_cache.loadData(fn, self.configuration.data, self.status)      
-
-        # Tweak some variables
-        item = self.bb_cache.getVar('PN', fn, True)
-        self.status.ignored_dependencies = set()
-        self.status.bbfile_priority[fn] = 1
-
-        # Remove external dependencies
-        self.status.task_deps[fn]['depends'] = {}
-        self.status.deps[fn] = []
-        self.status.rundeps[fn] = []
-        self.status.runrecs[fn] = []
-
-        # Remove stamp for target if force mode active
-        if self.configuration.force:
-            bb.msg.note(2, bb.msg.domain.RunQueue, "Remove stamp %s, %s" % (task, fn))
-            bb.build.del_stamp('do_%s' % task, self.status, fn)
-
-        # Setup taskdata structure
-        taskdata = bb.taskdata.TaskData(self.configuration.abort)
-        taskdata.add_provider(self.configuration.data, self.status, item)
-
-        buildname = bb.data.getVar("BUILDNAME", self.configuration.data)
-        bb.event.fire(bb.event.BuildStarted(buildname, [item], self.configuration.event_data))
-
-        # Execute the runqueue
-        runlist = [[item, "do_%s" % task]]
-
-        rq = bb.runqueue.RunQueue(self, self.configuration.data, self.status, taskdata, runlist)
-
-        def buildFileIdle(server, rq, abort):
-
-            if abort or self.cookerAction == cookerStop:
-                rq.finish_runqueue(True)
-            elif self.cookerAction == cookerShutdown:
-                rq.finish_runqueue(False)
-            failures = 0
-            try:
-                retval = rq.execute_runqueue()
-            except runqueue.TaskFailure, fnids:
-                for fnid in fnids:
-                    bb.msg.error(bb.msg.domain.Build, "'%s' failed" % taskdata.fn_index[fnid])
-                    failures = failures + 1
-                retval = False
-            if not retval:
-                self.command.finishAsyncCommand()
-                bb.event.fire(bb.event.BuildCompleted(buildname, targets, self.configuration.event_data, failures))
-                return False
-            return 0.5
-
-        self.server.register_idle_function(buildFileIdle, rq)
-
-    def buildTargets(self, targets, task):
-        """
-        Attempt to build the targets specified
-        """
-
-        # Need files parsed
-        self.updateCache()
-
-        # If we are told to do the NULL task then query the default task
-        if (task == None):
-            task = self.configuration.cmd
-
-        targets = self.checkPackages(targets)
-
-        def buildTargetsIdle(server, rq, abort):
-
-            if abort or self.cookerAction == cookerStop:
-                rq.finish_runqueue(True)
-            elif self.cookerAction == cookerShutdown:
-                rq.finish_runqueue(False)
-            failures = 0
-            try:
-                retval = rq.execute_runqueue()
-            except runqueue.TaskFailure, fnids:
-                for fnid in fnids:
-                    bb.msg.error(bb.msg.domain.Build, "'%s' failed" % taskdata.fn_index[fnid])
-                    failures = failures + 1
-                retval = False
-            if not retval:
-                self.command.finishAsyncCommand()
-                bb.event.fire(bb.event.BuildCompleted(buildname, targets, self.configuration.event_data, failures))
-                return None
-            return 0.5
-
-        self.buildSetVars()
-
-        buildname = bb.data.getVar("BUILDNAME", self.configuration.data)
-        bb.event.fire(bb.event.BuildStarted(buildname, targets, self.configuration.event_data))
-
-        localdata = data.createCopy(self.configuration.data)
-        bb.data.update_data(localdata)
-        bb.data.expandKeys(localdata)
-
-        taskdata = bb.taskdata.TaskData(self.configuration.abort)
-
-        runlist = []
-        for k in targets:
-            taskdata.add_provider(localdata, self.status, k)
-            runlist.append([k, "do_%s" % task])
-        taskdata.add_unresolved(localdata, self.status)
-
-        rq = bb.runqueue.RunQueue(self, self.configuration.data, self.status, taskdata, runlist)
-
-        self.server.register_idle_function(buildTargetsIdle, rq)
-
-    def updateCache(self):
-
-        if self.cookerState == cookerParsed:
-            return
-
-        if self.cookerState != cookerParsing:
-
-            self.parseConfiguration ()
-
-            # Import Psyco if available and not disabled
-            import platform
-            if platform.machine() in ['i386', 'i486', 'i586', 'i686']:
-                if not self.configuration.disable_psyco:
-                    try:
-                        import psyco
-                    except ImportError:
-                        bb.msg.note(1, bb.msg.domain.Collection, "Psyco JIT Compiler (http://psyco.sf.net) not available. Install it to increase performance.")
-                    else:
-                        psyco.bind( CookerParser.parse_next )
-                else:
-                    bb.msg.note(1, bb.msg.domain.Collection, "You have disabled Psyco. This decreases performance.")
-
-            self.status = bb.cache.CacheData()
-
-            ignore = bb.data.getVar("ASSUME_PROVIDED", self.configuration.data, 1) or ""
-            self.status.ignored_dependencies = set(ignore.split())
-    
-            for dep in self.configuration.extra_assume_provided:
-                self.status.ignored_dependencies.add(dep)
-    
-            self.handleCollections( bb.data.getVar("BBFILE_COLLECTIONS", self.configuration.data, 1) )
-
-            bb.msg.debug(1, bb.msg.domain.Collection, "collecting .bb files")
-            (filelist, masked) = self.collect_bbfiles()
-            bb.data.renameVar("__depends", "__base_depends", self.configuration.data)
-
-            self.parser = CookerParser(self, filelist, masked)
-            self.cookerState = cookerParsing
-
-        if not self.parser.parse_next():
-            bb.msg.debug(1, bb.msg.domain.Collection, "parsing complete")
-            self.buildDepgraph()
-            self.cookerState = cookerParsed
-            return None
-
-        return 0.00001
-
-    def checkPackages(self, pkgs_to_build):
-
-        if len(pkgs_to_build) == 0:
-            raise NothingToBuild
-
-        if 'world' in pkgs_to_build:
-            self.buildWorldTargetList()
-            pkgs_to_build.remove('world')
-            for t in self.status.world_target:
-                pkgs_to_build.append(t)
-
-        return pkgs_to_build
-
-    def get_bbfiles( self, path = os.getcwd() ):
-        """Get list of default .bb files by reading out the current directory"""
-        contents = os.listdir(path)
-        bbfiles = []
-        for f in contents:
-            (root, ext) = os.path.splitext(f)
-            if ext == ".bb":
-                bbfiles.append(os.path.abspath(os.path.join(os.getcwd(),f)))
-        return bbfiles
-
-    def find_bbfiles( self, path ):
-        """Find all the .bb files in a directory"""
-        from os.path import join
-
-        found = []
-        for dir, dirs, files in os.walk(path):
-            for ignored in ('SCCS', 'CVS', '.svn'):
-                if ignored in dirs:
-                    dirs.remove(ignored)
-            found += [join(dir,f) for f in files if f.endswith('.bb')]
-
-        return found
-
-    def collect_bbfiles( self ):
-        """Collect all available .bb build files"""
-        parsed, cached, skipped, masked = 0, 0, 0, 0
-        self.bb_cache = bb.cache.init(self)
-
-        files = (data.getVar( "BBFILES", self.configuration.data, 1 ) or "").split()
-        data.setVar("BBFILES", " ".join(files), self.configuration.data)
-
-        if not len(files):
-            files = self.get_bbfiles()
-
-        if not len(files):
-            bb.msg.error(bb.msg.domain.Collection, "no files to build.")
-
-        newfiles = []
-        for f in files:
-            if os.path.isdir(f):
-                dirfiles = self.find_bbfiles(f)
-                if dirfiles:
-                    newfiles += dirfiles
-                    continue
-            else:
-                globbed = glob.glob(f)
-                if not globbed and os.path.exists(f):
-                    globbed = [f]
-                newfiles += globbed
-
-        bbmask = bb.data.getVar('BBMASK', self.configuration.data, 1)
-
-        if not bbmask:
-            return (newfiles, 0)
-
-        try:
-            bbmask_compiled = re.compile(bbmask)
-        except sre_constants.error:
-            bb.msg.fatal(bb.msg.domain.Collection, "BBMASK is not a valid regular expression.")
-
-        finalfiles = []
-        for f in newfiles:
-            if bbmask_compiled.search(f):
-                bb.msg.debug(1, bb.msg.domain.Collection, "skipping masked file %s" % f)
-                masked += 1
-                continue
-            finalfiles.append(f)
-
-        return (finalfiles, masked)
-
-    def serve(self):
-
-        # Empty the environment. The environment will be populated as
-        # necessary from the data store.
-        bb.utils.empty_environment()
-
-        if self.configuration.profile:
-            try:
-                import cProfile as profile
-            except:
-                import profile
-
-            profile.runctx("self.server.serve_forever()", globals(), locals(), "profile.log")
-
-            # Redirect stdout to capture profile information
-            pout = open('profile.log.processed', 'w')
-            so = sys.stdout.fileno()
-            os.dup2(pout.fileno(), so)
-
-            import pstats
-            p = pstats.Stats('profile.log')
-            p.sort_stats('time')
-            p.print_stats()
-            p.print_callers()
-            p.sort_stats('cumulative')
-            p.print_stats()
-
-            os.dup2(so, pout.fileno())
-            pout.flush()
-            pout.close()
-        else:
-            self.server.serve_forever()
-        
-        bb.event.fire(CookerExit(self.configuration.event_data))
-        
-class CookerExit(bb.event.Event):
-    """
-    Notify clients of the Cooker shutdown
-    """
-
-    def __init__(self, d):
-        bb.event.Event.__init__(self, d)
-
-class CookerParser:
-    def __init__(self, cooker, filelist, masked):
-        # Internal data
-        self.filelist = filelist
-        self.cooker = cooker
-
-        # Accounting statistics
-        self.parsed = 0
-        self.cached = 0
-        self.skipped = 0
-        self.error = 0
-        self.masked = masked
-        self.total = len(filelist)
-
-        # Pointer to the next file to parse
-        self.pointer = 0
-
-    def parse_next(self):
-        print "Pointer %d" % self.pointer
-
-        if self.pointer < len(self.filelist):
-            f = self.filelist[self.pointer]
-            cooker = self.cooker
-
-            try:
-                fromCache, skip = cooker.bb_cache.loadData(f, cooker.configuration.data, cooker.status)
-                if skip:
-                    self.skipped += 1
-                    bb.msg.debug(2, bb.msg.domain.Collection, "skipping %s" % f)
-                    cooker.bb_cache.skip(f)
-                elif fromCache: self.cached += 1
-                else: self.parsed += 1
-
-            except IOError, e:
-                self.error += 1
-                cooker.bb_cache.remove(f)
-                bb.msg.error(bb.msg.domain.Collection, "opening %s: %s" % (f, e))
-                pass
-            except KeyboardInterrupt:
-                cooker.bb_cache.remove(f)
-                cooker.bb_cache.sync()
-                raise
-            except Exception, e:
-                self.error += 1
-                cooker.bb_cache.remove(f)
-                bb.msg.error(bb.msg.domain.Collection, "%s while parsing %s" % (e, f))
-            except:
-                cooker.bb_cache.remove(f)
-                raise
-            finally:
-                bb.event.fire(bb.event.ParseProgress(cooker.configuration.event_data, self.cached, self.parsed, self.skipped, self.masked, self.error, self.total))
-
-            self.pointer += 1
-
-        if self.pointer >= self.total:
-            cooker.bb_cache.sync()
-            if self.error > 0:
-                raise ParsingErrorsFound
-            return False
-        return True
-
--- a/bitbake-dev/lib/bb/daemonize.py
+++ b/bitbake-dev/lib/bb/daemonize.py
@@ -1,191 +0,0 @@
-"""
-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, 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, 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-dev/lib/bb/data.py
+++ b/bitbake-dev/lib/bb/data.py
@@ -1,562 +0,0 @@
-# ex:ts=4:sw=4:sts=4:et
-# -*- tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*-
-"""
-BitBake 'Data' implementations
-
-Functions for interacting with the data structure used by the
-BitBake build tools.
-
-The expandData and update_data are the most expensive
-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 
-monster seems to be right. We will track setVar more carefully
-to have faster update_data and expandKeys operations.
-
-This is a treade-off between speed and memory again but
-the speed is more critical here.
-"""
-
-# Copyright (C) 2003, 2004  Chris Larson
-# Copyright (C) 2005        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.
-#
-#Based on functions from the base bb module, Copyright 2003 Holger Schurig
-
-import sys, os, re, types
-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)
-
-from bb import data_smart
-import bb
-
-_dict_type = data_smart.DataSmart
-
-def init():
-    return _dict_type()
-
-def init_db(parent = None):
-    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()
-
-def initVar(var, d):
-    """Non-destructive var init for data structure"""
-    d.initVar(var)
-
-
-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)
-
-
-def getVar(var, d, exp = 0):
-    """Gets the value of a variable
-
-    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
-
-    Example:
-        >>> d = init()
-        >>> setVar('TEST', 'testcontents', d)
-        >>> renameVar('TEST', 'TEST2', d)
-        >>> print getVar('TEST2', d)
-        testcontents
-    """
-    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
-    """
-    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)
-
-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)
-
-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)
-
-def setVarFlags(var, flags, d):
-    """Set the flags for a given variable
-
-    Note:
-        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)
-
-def getVarFlags(var, d):
-    """Gets a variable's flags
-
-    Example:
-        >>> d = init()
-        >>> setVarFlag('TEST', 'test', 'blah', d)
-        >>> print getVarFlags('TEST', d)['test']
-        blah
-    """
-    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
-
-    """
-    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 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}
-    """
-    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
-
-        ekey = expand(key, readdata)
-        if key == ekey:
-            continue
-        todolist[key] = ekey
-
-    # These two for loops are split for performance to maximise the 
-    # usefulness of the expand cache
-
-    for key in todolist:
-        ekey = todolist[key]
-        renameVar(key, ekey, 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)
-
-def inheritFromOS(d):
-    """Inherit variables from the environment."""
-    for s in os.environ.keys():
-        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:
-        raise
-    except:
-        excname = str(sys.exc_info()[0])
-        if excname == "bb.build.FuncFailed":
-            raise
-        o.write('# expansion of %s threw %s\n' % (var, excname))
-        return 0
-
-    if all:
-        o.write('# %s=%s\n' % (var, oval))
-
-    if type(val) is not types.StringType:
-        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
-
-    varExpanded = expand(var, d)
-
-    if unexport:
-        o.write('unset %s\n' % varExpanded)
-        return 1
-
-    val.rstrip()
-    if not val:
-        return 0
-
-    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)
-
-    for e in env:
-        if getVarFlag(e, "func", d):
-            continue
-        emit_var(e, o, d, all) and o.write('\n')
-
-    for e in env:
-        if not getVarFlag(e, "func", d):
-            continue
-        emit_var(e, o, d) and o.write('\n')
-
-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.
-
-        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
-
-        Overrides:
-        >>> setVar('TEST_arm', 'target', d)
-        >>> setVar('TEST_ramses', 'machine', d)
-        >>> setVar('TEST_local', 'local', d)
-        >>> setVar('OVERRIDES', 'arm', d)
-
-        >>> setVar('TEST', 'original', d)
-        >>> update_data(d)
-        >>> print getVar('TEST', d)
-        target
-
-        >>> setVar('OVERRIDES', 'arm:ramses:local', d)
-        >>> setVar('TEST', 'original', d)
-        >>> update_data(d)
-        >>> print getVar('TEST', d)
-        local
-
-        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)
-
-
-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
-    import bb
-    from bb import data
-    bb.msg.set_debug_level(0)
-    doctest.testmod(data)
-
-if __name__ == "__main__":
-    _test()
--- a/bitbake-dev/lib/bb/data_smart.py
+++ b/bitbake-dev/lib/bb/data_smart.py
@@ -1,288 +0,0 @@
-# ex:ts=4:sw=4:sts=4:et
-# -*- tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*-
-"""
-BitBake Smart Dictionary Implementation
-
-Functions for interacting with the data structure used by the
-BitBake build tools.
-
-"""
-
-# Copyright (C) 2003, 2004  Chris Larson
-# Copyright (C) 2004, 2005  Seb Frankengul
-# Copyright (C) 2005, 2006  Holger Hans Peter Freyther
-# Copyright (C) 2005        Uli Luckas
-# Copyright (C) 2005        ROAD GmbH
-#
-# 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 copy, os, re, sys, time, types
-import bb
-from bb   import utils, methodpool
-from COW  import COWDictBase
-from new  import classobj
-
-
-__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 DataSmart:
-    def __init__(self, special = COWDictBase.copy(), seen = COWDictBase.copy() ):
-        self.dict = {}
-
-        # cookie monster tribute
-        self._special_values = special
-        self._seen_overrides = seen
-
-        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 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 varname and varname in self.expand_cache:
-            return self.expand_cache[varname]
-
-        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))
-            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
-
-        return s
-
-    def initVar(self, var):
-        self.expand_cache = {}
-        if not var in self.dict:
-            self.dict[var] = {}
-
-    def _findVar(self,var):
-        _dest = self.dict
-
-        while (_dest and var not in _dest):
-            if not "_data" in _dest:
-                _dest = None
-                break
-            _dest = _dest["_data"]
-
-        if _dest and var in _dest:
-            return _dest[var]
-        return None
-
-    def _makeShadowCopy(self, var):
-        if var in self.dict:
-            return
-
-        local_var = self._findVar(var)
-
-        if local_var:
-            self.dict[var] = copy.copy(local_var)
-        else:
-            self.initVar(var)
-
-    def setVar(self,var,value):
-        self.expand_cache = {}
-        match  = __setvar_regexp__.match(var)
-        if match and match.group("keyword") in __setvar_keyword__:
-            base = match.group('base')
-            keyword = match.group("keyword")
-            override = match.group('add')
-            l = self.getVarFlag(base, keyword) or []
-            l.append([value, override])
-            self.setVarFlag(base, keyword, l)
-
-            # todo make sure keyword is not __doc__ or __module__
-            # pay the cookie monster
-            try:
-                self._special_values[keyword].add( base )
-            except:
-                self._special_values[keyword] = set()
-                self._special_values[keyword].add( base )
-
-            return
-
-        if not var in self.dict:
-            self._makeShadowCopy(var)
-
-        # 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()
-            self._seen_overrides[override].add( var )
-
-        # setting var
-        self.dict[var]["content"] = value
-
-    def getVar(self,var,exp):
-        value = self.getVarFlag(var,"content")
-
-        if exp and value:
-            return self.expand(value,var)
-        return value
-
-    def renameVar(self, key, newkey):
-        """
-        Rename the variable key to newkey 
-        """
-        val = self.getVar(key, 0)
-        if val is None:
-            return
-
-        self.setVar(newkey, val)
-
-        for i in ('_append', '_prepend'):
-            dest = self.getVarFlag(newkey, i) or []
-            src = self.getVarFlag(key, i) or []
-            dest.extend(src)
-            self.setVarFlag(newkey, i, dest)
-            
-            if self._special_values.has_key(i) 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):
-        if not var in self.dict:
-            self._makeShadowCopy(var)
-        self.dict[var][flag] = flagvalue
-
-    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):
-        local_var = self._findVar(var)
-        if not local_var:
-            return
-        if not var in self.dict:
-            self._makeShadowCopy(var)
-
-        if var in self.dict and flag in self.dict[var]:
-            del self.dict[var][flag]
-
-    def setVarFlags(self,var,flags):
-        if not var in self.dict:
-            self._makeShadowCopy(var)
-
-        for i in flags.keys():
-            if i == "content":
-                continue
-            self.dict[var][i] = flags[i]
-
-    def getVarFlags(self,var):
-        local_var = self._findVar(var)
-        flags = {}
-
-        if local_var:
-            for i in local_var.keys():
-                if i == "content":
-                    continue
-                flags[i] = local_var[i]
-
-        if len(flags) == 0:
-            return None
-        return flags
-
-
-    def delVarFlags(self,var):
-        if not var in self.dict:
-            self._makeShadowCopy(var)
-
-        if var in self.dict:
-            content = None
-
-            # try to save the content
-            if "content" in self.dict[var]:
-                content  = self.dict[var]["content"]
-                self.dict[var]            = {}
-                self.dict[var]["content"] = content
-            else:
-                del self.dict[var]
-
-
-    def createCopy(self):
-        """
-        Create a copy of self by setting _data to self
-        """
-        # we really want this to be a DataSmart...
-        data = DataSmart(seen=self._seen_overrides.copy(), special=self._special_values.copy())
-        data.dict["_data"] = self.dict
-
-        return data
-
-    # Dictionary Methods
-    def keys(self):
-        def _keys(d, mykey):
-            if "_data" in d:
-                _keys(d["_data"],mykey)
-
-            for key in d.keys():
-                if key != "_data":
-                    mykey[key] = None
-        keytab = {}
-        _keys(self.dict,keytab)
-        return keytab.keys()
-
-    def __getitem__(self,item):
-        #print "Warning deprecated"
-        return self.getVar(item, False)
-
-    def __setitem__(self,var,data):
-        #print "Warning deprecated"
-        self.setVar(var,data)
-
-
--- a/bitbake-dev/lib/bb/event.py
+++ b/bitbake-dev/lib/bb/event.py
@@ -1,302 +0,0 @@
-# ex:ts=4:sw=4:sts=4:et
-# -*- tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*-
-"""
-BitBake 'Event' implementation
-
-Classes and functions for manipulating 'events' in 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, re
-import bb.utils
-
-# This is the pid for which we should generate the event. This is set when
-# the runqueue forks off.
-worker_pid = 0
-
-class Event:
-    """Base class for events"""
-    type = "Event"
-
-    def __init__(self, d):
-        self._data = d
-        self.pid = worker_pid
-
-    def getData(self):
-        return self._data
-
-    def setData(self, data):
-        self._data = data
-
-    data = property(getData, setData, None, "data property")
-
-NotHandled = 0
-Handled = 1
-
-Registered        = 10
-AlreadyRegistered = 14
-
-# Internal
-_handlers = {}
-_ui_handlers = {}
-_ui_handler_seq = 0
-
-def fire(event):
-    """Fire off an Event"""
-
-    for handler in _handlers:
-        h = _handlers[handler]
-        if type(h).__name__ == "code":
-            exec(h)
-            tmpHandler(event)
-        else:
-            h(event)
-
-    # Remove the event data elements for UI handlers - too much data otherwise
-    # They can request data if they need it
-    event.data = None
-    event._data = None
-
-    errors = []
-    for h in _ui_handlers:
-        #print "Sending event %s" % event
-        classid = "%s.%s" % (event.__class__.__module__, event.__class__.__name__)
-        try:
-            _ui_handlers[h].event.send((classid, event))
-        except:
-            errors.append(h)
-    for h in errors:
-        del _ui_handlers[h]
-
-def register(name, handler):
-    """Register an Event handler"""
-
-    # already registered
-    if name in _handlers:
-        return AlreadyRegistered
-
-    if handler is not None:
-        # handle string containing python code
-        if type(handler).__name__ == "str":
-            tmp = "def tmpHandler(e):\n%s" % handler
-            comp = bb.utils.better_compile(tmp, "tmpHandler(e)", "bb.event._registerCode")
-            _handlers[name] = comp
-        else:
-            _handlers[name] = handler
-
-        return Registered
-
-def remove(name, handler):
-    """Remove an Event handler"""
-    _handlers.pop(name)
-
-def register_UIHhandler(handler):
-    bb.event._ui_handler_seq = bb.event._ui_handler_seq + 1
-    _ui_handlers[_ui_handler_seq] = handler
-    return _ui_handler_seq
-
-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"""
-    if getattr(e, "__name__", None) == None:
-        return e.__class__.__name__
-    else:
-        return e.__name__
-
-class ConfigParsed(Event):
-    """Configuration Parsing Complete"""
-
-class RecipeParsed(Event):
-    """ Recipe Parsing Complete """
-
-    def __init__(self, fn, d):
-        self.fn = fn
-        Event.__init__(self, d)
-
-class StampUpdate(Event):
-    """Trigger for any adjustment of the stamp files to happen"""
-
-    def __init__(self, targets, stampfns, d):
-        self._targets = targets
-        self._stampfns = stampfns
-        Event.__init__(self, d)
-
-    def getStampPrefix(self):
-        return self._stampfns
-
-    def getTargets(self):
-        return self._targets
-
-    stampPrefix = property(getStampPrefix)
-    targets = property(getTargets)
-
-class PkgBase(Event):
-    """Base class for package events"""
-
-    def __init__(self, t, d):
-        self._pkg = t
-        Event.__init__(self, d)
-        self._message = "package %s: %s" % (bb.data.getVar("P", d, 1), getName(self)[3:])
-
-    def getPkg(self):
-        return self._pkg
-
-    def setPkg(self, pkg):
-        self._pkg = pkg
-
-    pkg = property(getPkg, setPkg, None, "pkg property")
-
-
-class BuildBase(Event):
-    """Base class for bbmake run events"""
-
-    def __init__(self, n, p, c, failures = 0):
-        self._name = n
-        self._pkgs = p
-        Event.__init__(self, c)
-        self._failures = failures
-
-    def getPkgs(self):
-        return self._pkgs
-
-    def setPkgs(self, pkgs):
-        self._pkgs = pkgs
-
-    def getName(self):
-        return self._name
-
-    def setName(self, name):
-        self._name = name
-
-    def getCfg(self):
-        return self.data
-
-    def setCfg(self, cfg):
-        self.data = cfg
-
-    def getFailures(self):
-        """
-        Return the number of failed packages
-        """
-        return self._failures
-
-    pkgs = property(getPkgs, setPkgs, None, "pkgs property")
-    name = property(getName, setName, None, "name property")
-    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 BuildStarted(BuildBase):
-    """bbmake build run started"""
-
-
-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)
-        self._item = item
-        self._runtime = runtime
-
-    def getItem(self):
-        return self._item
-
-    def isRuntime(self):
-        return self._runtime
-
-class MultipleProviders(Event):
-    """Multiple Providers"""
-
-    def  __init__(self, item, candidates, data, runtime = False):
-        Event.__init__(self, data)
-        self._item = item
-        self._candidates = candidates
-        self._is_runtime = runtime
-
-    def isRuntime(self):
-        """
-        Is this a runtime issue?
-        """
-        return self._is_runtime
-
-    def getItem(self):
-        """
-        The name for the to be build item
-        """
-        return self._item
-
-    def getCandidates(self):
-        """
-        Get the possible Candidates for a PROVIDER.
-        """
-        return self._candidates
-
-class ParseProgress(Event):
-    """
-    Parsing Progress Event
-    """
-
-    def __init__(self, d, cached, parsed, skipped, masked, errors, total):
-        Event.__init__(self, d)
-        self.cached = cached
-        self.parsed = parsed
-        self.skipped = skipped
-        self.masked = masked
-        self.errors = errors
-        self.sofar = cached + parsed + skipped
-        self.total = total
-
-class DepTreeGenerated(Event):
-    """
-    Event when a dependency tree has been generated
-    """
-
-    def __init__(self, d, depgraph):
-        Event.__init__(self, d)
-        self._depgraph = depgraph
-
--- a/bitbake-dev/lib/bb/fetch/init.py
+++ b/bitbake-dev/lib/bb/fetch/init.py
@@ -1,606 +0,0 @@
-# ex:ts=4:sw=4:sts=4:et
-# -*- tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*-
-"""
-BitBake 'Fetch' implementations
-
-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.
-#
-# Based on functions from the base bb module, Copyright 2003 Holger Schurig
-
-import os, re
-import bb
-from   bb import data
-from   bb import persist_data
-
-class FetchError(Exception):
-    """Exception raised when a download fails"""
-
-class NoMethodError(Exception):
-    """Exception raised when there is no method to obtain a supplied url or set of urls"""
-
-class MissingParameterError(Exception):
-    """Exception raised when a fetch method is missing a critical parameter in the url"""
-
-class ParameterError(Exception):
-    """Exception raised when a url cannot be proccessed due to invalid parameters."""
-
-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 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 = ['','','','','',{}]
-    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:
-            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:
-                    if d:
-                        localfn = bb.fetch.localpath(uri, d)
-                        if localfn:
-                            result_decoded[loc] = os.path.dirname(result_decoded[loc]) + "/" + os.path.basename(bb.fetch.localpath(uri, d))
-#                       bb.msg.note(1, bb.msg.domain.Fetcher, "uri_replace: matching %s against %s and replacing with %s" % (i, uri_decoded[loc], uri_replace_decoded[loc]))
-            else:
-#               bb.msg.note(1, bb.msg.domain.Fetcher, "uri_replace: no match")
-                return uri
-#           else:
-#               for j in i.keys():
-#                   FIXME: apply replacements against options
-    return bb.encodeurl(result_decoded)
-
-methods = []
-urldata_cache = {}
-saved_headrevs = {}
-
-def fetcher_init(d):
-    """
-    Called to initilize the fetchers once the configuration data is known
-    Calls before this must not hit the cache.
-    """
-    pd = persist_data.PersistData(d)
-    # When to drop SCM head revisions controled 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:
-        bb.msg.fatal(bb.msg.domain.Fetcher, "Invalid SRCREV cache policy of: %s" % srcrev_policy)
-    # 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)
-    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 go(d):
-    """
-    Fetch all urls
-    init must have previously been called
-    """
-    urldata = init([], d, True)
-
-    for u in urldata:
-        ud = urldata[u]
-        m = ud.method
-        if ud.localfile:
-            if not m.forcefetch(u, ud, d) and os.path.exists(ud.md5):
-                # File already present along with md5 stamp file
-                # Touch md5 file to show activity
-                try:
-                    os.utime(ud.md5, None)
-                except:
-                    # Errors aren't fatal here
-                    pass
-                continue
-            lf = bb.utils.lockfile(ud.lockfile)
-            if not m.forcefetch(u, ud, d) and os.path.exists(ud.md5):
-                # If someone else fetched this before we got the lock, 
-                # notice and don't try again
-                try:
-                    os.utime(ud.md5, None)
-                except:
-                    # Errors aren't fatal here
-                    pass
-                bb.utils.unlockfile(lf)
-                continue
-        m.go(u, ud, d)
-        if ud.localfile:
-            if not m.forcefetch(u, ud, d):
-                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.note(1, bb.msg.domain.Fetcher, "Testing URL %s" % u)
-        ret = m.checkstatus(u, ud, d)
-        if not ret:
-            bb.msg.fatal(bb.msg.domain.Fetcher, "URL %s doesn't work" % u)
-
-def localpaths(d):
-    """
-    Return a list of the local filenames, assuming successful fetch
-    """
-    local = []
-    urldata = init([], d, True)
-
-    for u in urldata:
-        ud = urldata[u]      
-        local.append(ud.localpath)
-
-    return local
-
-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
-
-    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', '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 1:
-        line = stdout_handle.readline()
-        if not line:
-            break
-        if not quiet:
-            print line,
-        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
-
-class FetchData(object):
-    """
-    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) = bb.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"]
-        else:
-            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)
-        self.md5 = self.localpath + '.md5'
-        self.lockfile = self.localpath + '.lock'
-
-
-class Fetch(object):
-    """Base class for 'fetch'ing data"""
-
-    def __init__(self, urls = []):
-        self.urls = []
-
-    def supports(self, url, urldata, d):
-        """
-        Check to see if this fetch class supports a given url.
-        """
-        return 0
-
-    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 
-        and duplicate code execution)
-        """
-        return url
-
-    def setUrls(self, urls):
-        self.__urls = urls
-
-    def getUrls(self):
-        return self.__urls
-
-    urls = property(getUrls, setUrls, None, "Urls property")
-
-    def forcefetch(self, url, urldata, d):
-        """
-        Force a fetch, even if localpath exists?
-        """
-        return False
-
-    def suppports_srcrev(self):
-        """
-        The fetcher supports auto source revisions (SRCREV)
-        """
-        return False
-
-    def go(self, url, urldata, d):
-        """
-        Fetch urls
-        Assumes localpath was called first
-        """
-        raise NoMethodError("Missing implementation for url")
-
-    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
-
-        d the bb.data module
-        """
-        if "srcdate" in urldata.parm:
-            return urldata.parm['srcdate']
-
-        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("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 srcrev_internal_helper(ud, d):
-        """
-        Return:
-            a) a source revision if specified
-	    b) True if auto srcrev is in action
-	    c) False otherwise
-        """
-
-        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_pn-" + pn + "_" + 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
-
-    srcrev_internal_helper = staticmethod(srcrev_internal_helper)
-
-    def try_mirror(d, tarfn):
-        """
-        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)
-            return True
-
-        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()
-
-        ld = d.createCopy()
-        for stash in src_tarball_stash:
-            url = stash + tarfn
-            try:
-                ud = FetchData(url, ld)
-            except bb.fetch.NoMethodError:
-                bb.msg.debug(1, bb.msg.domain.Fetcher, "No method for %s" % url)
-                continue
-
-            ud.setup_localpath(ld)
-
-            try:
-                ud.method.go(url, ud, ld)
-                return True
-            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, "Tarball stash fetch failure: %s" % value)
-        return False
-    try_mirror = staticmethod(try_mirror)
-
-    def verify_md5sum(ud, got_sum):
-        """
-        Verify the md5sum we wanted with the one we got
-        """
-        wanted_sum = None
-        if 'md5sum' in ud.parm:
-            wanted_sum = ud.parm['md5sum']
-        if not wanted_sum:
-            return True
-
-        return wanted_sum == got_sum
-    verify_md5sum = staticmethod(verify_md5sum)
-
-    def write_md5sum(url, ud, d):
-        md5data = bb.utils.md5_file(ud.localpath)
-        # verify the md5sum
-        if not Fetch.verify_md5sum(ud, md5data):
-            raise MD5SumError(url)
-
-        md5out = file(ud.md5, 'w')
-        md5out.write(md5data)
-        md5out.close()
-    write_md5sum = staticmethod(write_md5sum)
-
-    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)
-        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):
-        """
-        
-        """
-        has_sortable = hasattr(self, "_sortable_revision")
-        if has_sortable:
-            return self._sortable_revision(url, ud, d)
-
-        pd = persist_data.PersistData(d)
-        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")
-        count = pd.getValue("BB_URI_LOCALCOUNT", key + "_count")
-
-        if last_rev == latest_rev:
-            return str(count + "+" + latest_rev)
-
-        if count is None:
-            count = "0"
-        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 "")
-
-import cvs
-import git
-import local
-import svn
-import wget
-import svk
-import ssh
-import perforce
-import bzr
-import hg
-import osc
-
-methods.append(local.Local())
-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())
--- a/bitbake-dev/lib/bb/fetch/bzr.py
+++ b/bitbake-dev/lib/bb/fetch/bzr.py
@@ -1,153 +0,0 @@
-"""
-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"""
-
-        # try to use the tarball stash
-        if Fetch.try_mirror(d, ud.localfile):
-            bb.msg.debug(1, bb.msg.domain.Fetcher, "%s already exists or was mirrored, skipping bzr checkout." % ud.localpath)
-            return
-
-        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-dev/lib/bb/fetch/cvs.py
+++ b/bitbake-dev/lib/bb/fetch/cvs.py
@@ -1,182 +0,0 @@
-# ex:ts=4:sw=4:sts=4:et
-# -*- tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*-
-"""
-BitBake 'Fetch' implementations
-
-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.
-#
-#Based on functions from the base bb module, Copyright 2003 Holger Schurig
-#
-
-import os
-import bb
-from   bb import data
-from   bb.fetch import Fetch
-from   bb.fetch import FetchError
-from   bb.fetch import MissingParameterError
-
-class Cvs(Fetch):
-    """
-    Class to fetch a module or modules from cvs repositories
-    """
-    def supports(self, url, ud, d):
-        """
-        Check to see if a given url can be fetched with cvs.
-        """
-        return ud.type in ['cvs', 'pserver']
-
-    def localpath(self, url, ud, d):
-        if not "module" in ud.parm:
-            raise MissingParameterError("cvs method needs a 'module' parameter")
-        ud.module = ud.parm["module"]
-
-        ud.tag = ""
-        if 'tag' in ud.parm:
-            ud.tag = ud.parm['tag']
-
-        # Override the default date in certain cases
-        if 'date' in ud.parm:
-            ud.date = ud.parm['date']
-        elif ud.tag:
-            ud.date = ""
-
-        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)
-
-    def forcefetch(self, url, ud, d):
-        if (ud.date == "now"):
-            return True
-        return False
-
-    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"]
-
-        localdir = ud.module
-        if "localdir" in ud.parm:
-            localdir = ud.parm["localdir"]
-
-        cvs_port = ""
-        if "port" in ud.parm:
-            cvs_port = ud.parm["port"]
-
-        cvs_rsh = None
-        if method == "ext":
-            if "rsh" in ud.parm:
-                cvs_rsh = ud.parm["rsh"]
-
-        if method == "dir":
-            cvsroot = ud.path
-        else:
-            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:
-            # 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)
-
-        localdata = data.createCopy(d)
-        data.setVar('OVERRIDES', "cvs:%s" % data.getVar('OVERRIDES', localdata), localdata)
-        data.update_data(localdata)
-
-        data.setVar('CVSROOT', cvsroot, localdata)
-        data.setVar('CVSCOOPTS', " ".join(options), localdata)
-        data.setVar('CVSMODULE', ud.module, localdata)
-        cvscmd = data.getVar('FETCHCOMMAND', localdata, 1)
-        cvsupdatecmd = data.getVar('UPDATECOMMAND', localdata, 1)
-
-        if cvs_rsh:
-            cvscmd = "CVS_RSH=\"%s\" %s" % (cvs_rsh, cvscmd)
-            cvsupdatecmd = "CVS_RSH=\"%s\" %s" % (cvs_rsh, cvsupdatecmd)
-
-        # create module directory
-        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):
-            bb.msg.note(1, bb.msg.domain.Fetcher, "Update " + loc)
-            # update sources there
-            os.chdir(moddir)
-            myret = os.system(cvsupdatecmd)
-        else:
-            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" % cvscmd)
-            myret = os.system(cvscmd)
-
-        if myret != 0 or not os.access(moddir, os.R_OK):
-            try:
-                os.rmdir(moddir)
-            except OSError:
-                 pass
-            raise FetchError(ud.module)
-
-        # tar them up to a defined filename
-        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)
-            except OSError:
-                pass
-            raise FetchError(ud.module)
--- a/bitbake-dev/lib/bb/fetch/git.py
+++ b/bitbake-dev/lib/bb/fetch/git.py
@@ -1,188 +0,0 @@
-# ex:ts=4:sw=4:sts=4:et
-# -*- tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*-
-"""
-BitBake 'Fetch' git implementation
-
-"""
-
-#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 Git(Fetch):
-    """Class to fetch a module or modules from git repositories"""
-    def supports(self, url, ud, d):
-        """
-        Check to see if a given url can be fetched with git.
-        """
-        return ud.type in ['git']
-
-    def localpath(self, url, ud, d):
-
-        if 'protocol' in ud.parm:
-            ud.proto = ud.parm['protocol']
-        elif not ud.host:
-            ud.proto = 'file'
-        else:
-            ud.proto = "rsync"
-
-        ud.branch = ud.parm.get("branch", "master")
-
-        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)	
-
-        ud.localfile = data.expand('git_%s%s_%s.tar.gz' % (ud.host, ud.path.replace('/', '.'), ud.tag), d)
-
-        return os.path.join(data.getVar("DL_DIR", d, True), ud.localfile)
-
-    def go(self, loc, ud, d):
-        """Fetch url"""
-
-        if 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)
-
-        coname = '%s' % (ud.tag)
-        codir = os.path.join(repodir, coname)
-
-        if not os.path.exists(repodir):
-            if Fetch.try_mirror(d, repofilename):    
-                bb.mkdirhier(repodir)
-                os.chdir(repodir)
-                runfetchcmd("tar -xzf %s" % (repofile), d)
-            else:
-                runfetchcmd("git clone -n %s://%s%s%s %s" % (ud.proto, username, ud.host, ud.path, repodir), d)
-
-        os.chdir(repodir)
-        # Remove all but the .git directory
-        if not self._contains_ref(ud.tag, d):
-            runfetchcmd("rm * -Rf", d)
-            runfetchcmd("git fetch %s://%s%s%s %s" % (ud.proto, username, ud.host, ud.path, ud.branch), d)
-            runfetchcmd("git fetch --tags %s://%s%s%s" % (ud.proto, username, ud.host, ud.path), d)
-            runfetchcmd("git prune-packed", d)
-            runfetchcmd("git pack-redundant --all | xargs -r rm", d)
-
-        os.chdir(repodir)
-        mirror_tarballs = data.getVar("BB_GENERATE_MIRROR_TARBALLS", d, True)
-        if mirror_tarballs != "0": 
-            bb.msg.note(1, bb.msg.domain.Fetcher, "Creating tarball of git repository")
-            runfetchcmd("tar -czf %s %s" % (repofile, os.path.join(".", ".git", "*") ), d)
-
-        if os.path.exists(codir):
-            bb.utils.prunedir(codir)
-
-        bb.mkdirhier(codir)
-        os.chdir(repodir)
-        runfetchcmd("git read-tree %s" % (ud.tag), d)
-        runfetchcmd("git checkout-index -q -f --prefix=%s -a" % (os.path.join(codir, "git", "")), d)
-
-        os.chdir(codir)
-        bb.msg.note(1, bb.msg.domain.Fetcher, "Creating tarball of git checkout")
-        runfetchcmd("tar -czf %s %s" % (ud.localpath, os.path.join(".", "*") ), d)
-
-        os.chdir(repodir)
-        bb.utils.prunedir(codir)
-
-    def suppports_srcrev(self):
-        return True
-
-    def _contains_ref(self, tag, d):
-        output = runfetchcmd("git log --pretty=oneline -n 1 %s -- 2> /dev/null | wc -l" % 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('/', '.')
-
-    def _latest_revision(self, url, ud, d):
-        """
-        Compute the HEAD revision for the url
-        """
-        if ud.user:
-            username = ud.user + '@'
-        else:
-            username = ""
-
-        output = runfetchcmd("git ls-remote %s://%s%s%s %s" % (ud.proto, username, ud.host, ud.path, ud.branch), d, True)
-        return output.split()[0]
-
-    def _build_revision(self, url, ud, d):
-        return ud.tag
-
-    def _want_sortable_revision(self, url, ud, d):
-        return bb.data.getVar("BB_GIT_CLONE_FOR_SRCREV", d, True) or False
-
-    def _sortable_revision_disabled(self, url, ud, d):
-        """
-        This is only called when _want_sortable_revision called true
-
-        We will have to get the updated revision.
-        """
-        gitsrcname = '%s%s' % (ud.host, ud.path.replace('/', '.'))
-        repodir = os.path.join(data.expand('${GITDIR}', d), gitsrcname)
-
-        key = "GIT_CACHED_REVISION-%s-%s"  % (gitsrcname, ud.tag)
-        if bb.data.getVar(key, d):
-            return bb.data.getVar(key, d)
-
-
-        # Runtime warning on wrongly configured sources
-        if ud.tag == "1":
-            bb.msg.error(1, bb.msg.domain.Fetcher, "SRCREV is '1'. This indicates a configuration error of %s" % url)
-            return "0+1"
-
-        cwd = os.getcwd()
-
-        # Check if we have the rev already
-        if not os.path.exists(repodir):
-            print "no repo"
-            self.go(None, ud, d)
-
-        os.chdir(repodir)
-        if not self._contains_ref(ud.tag, d):
-            self.go(None, ud, d)
-
-        output = runfetchcmd("git rev-list %s -- 2> /dev/null | wc -l" % ud.tag, d, quiet=True)
-        os.chdir(cwd)
-
-        sortable_revision = "%s+%s" % (output.split()[0], ud.tag)
-        bb.data.setVar(key, sortable_revision, d)
-        return sortable_revision
-        
-
--- a/bitbake-dev/lib/bb/fetch/hg.py
+++ b/bitbake-dev/lib/bb/fetch/hg.py
@@ -1,178 +0,0 @@
-# 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"""
-
-        # try to use the tarball stash
-        if Fetch.try_mirror(d, ud.localfile):
-            bb.msg.debug(1, bb.msg.domain.Fetcher, "%s already exists or was mirrored, skipping hg checkout." % ud.localpath)
-            return
-
-        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-dev/lib/bb/fetch/local.py
+++ b/bitbake-dev/lib/bb/fetch/local.py
@@ -1,72 +0,0 @@
-# ex:ts=4:sw=4:sts=4:et
-# -*- tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*-
-"""
-BitBake 'Fetch' implementations
-
-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.
-#
-# Based on functions from the base bb module, Copyright 2003 Holger Schurig
-
-import os
-import bb
-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.
-        """
-        return urldata.type in ['file','patch']
-
-    def localpath(self, url, urldata, d):
-        """
-        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)
-            if not newpath:
-                filesdir = data.getVar('FILESDIR', d, 1)
-                if filesdir:
-                    newpath = os.path.join(filesdir, path)
-        # We don't set localfile as for this fetcher the file is already local!
-        return newpath
-
-    def go(self, url, urldata, d):
-        """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-dev/lib/bb/fetch/osc.py
+++ b/bitbake-dev/lib/bb/fetch/osc.py
@@ -1,155 +0,0 @@
-# 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
-        """
-
-        # Try to use the tarball stash
-        if Fetch.try_mirror(d, ud.localfile):
-            bb.msg.debug(1, bb.msg.domain.Fetcher, "%s already exists or was mirrored, skipping osc checkout." % ud.localpath)
-            return
-
-        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-dev/lib/bb/fetch/perforce.py
+++ b/bitbake-dev/lib/bb/fetch/perforce.py
@@ -1,214 +0,0 @@
-# ex:ts=4:sw=4:sts=4:et
-# -*- tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*-
-"""
-BitBake 'Fetch' implementations
-
-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.
-#
-# Based on functions from the base bb module, Copyright 2003 Holger Schurig
-
-import os
-import bb
-from   bb import data
-from   bb.fetch import Fetch
-from   bb.fetch import FetchError
-
-class Perforce(Fetch):
-    def supports(self, url, ud, d):
-        return ud.type in ['p4']
-
-    def doparse(url,d):
-        parm = {}
-        path = url.split("://")[1]
-        delim = path.find("@");
-        if delim != -1:
-            (user,pswd,host,port) = path.split('@')[0].split(":")
-            path = path.split('@')[1]
-        else:
-            (host,port) = data.getVar('P4PORT', d).split(':')
-            user = ""
-            pswd = ""
-
-        if path.find(";") != -1:
-            keys=[]
-            values=[]
-            plist = path.split(';')
-            for item in plist:
-                if item.count('='):
-                    (key,value) = item.split('=')
-                    keys.append(key)
-                    values.append(value)
-
-            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
-    doparse = staticmethod(doparse)
-
-    def getcset(d, depot,host,user,pswd,parm):
-        p4opt = ""
-        if "cset" in parm:
-            return parm["cset"];
-        if user:
-            p4opt += " -u %s" % (user)
-        if pswd:
-            p4opt += " -P %s" % (pswd)
-        if host:
-            p4opt += " -p %s" % (host)
-
-        p4date = data.getVar("P4DATE", d, 1)
-        if "revision" in parm:
-            depot += "#%s" % (parm["revision"])
-        elif "label" in parm:
-            depot += "@%s" % (parm["label"])
-        elif p4date:
-            depot += "@%s" % (p4date)
-
-        p4cmd = data.getVar('FETCHCOMMAND_p4', d, 1)
-        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:
-            return -1
-
-        return cset.split(' ')[1]
-    getcset = staticmethod(getcset)
-
-    def localpath(self, url, ud, d):        
-
-        (host,path,user,pswd,parm) = Perforce.doparse(url,d)
-
-        # If a label is specified, we use that as our filename
-
-        if "label" in parm:
-            ud.localfile = "%s.tar.gz" % (parm["label"])
-            return os.path.join(data.getVar("DL_DIR", d, 1), ud.localfile)
-
-        base = path
-        which = path.find('/...')
-        if which != -1:
-            base = path[:which]
-
-        if base[0] == "/":
-            base = base[1:]
-
-        cset = Perforce.getcset(d, path, host, user, pswd, parm)
-
-        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)
-
-    def go(self, loc, ud, d):
-        """
-        Fetch urls
-        """
-
-        # try to use the tarball stash
-        if 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)
-
-        if depot.find('/...') != -1:
-            path = depot[:depot.find('/...')]
-        else:
-            path = depot
-
-        if "module" in parm:
-            module = parm["module"]
-        else:
-            module = os.path.basename(path)
-
-        localdata = data.createCopy(d)
-        data.setVar('OVERRIDES', "p4:%s" % data.getVar('OVERRIDES', localdata), localdata)
-        data.update_data(localdata)
-
-        # Get the p4 command
-        p4opt = ""
-        if user:
-            p4opt += " -u %s" % (user)
-
-        if pswd:
-            p4opt += " -P %s" % (pswd)
-
-        if host:
-            p4opt += " -p %s" % (host)
-
-        p4cmd = data.getVar('FETCHCOMMAND', localdata, 1)
-
-        # create temp directory
-        bb.msg.debug(2, bb.msg.domain.Fetcher, "Fetch: creating temporary directory")
-        bb.mkdirhier(data.expand('${WORKDIR}', localdata))
-        data.setVar('TMPBASE', data.expand('${WORKDIR}/oep4.XXXXXX', localdata), localdata)
-        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.")
-            raise FetchError(module)
-
-        if "label" in parm:
-            depot = "%s@%s" % (depot,parm["label"])
-        else:
-            cset = Perforce.getcset(d, depot, host, user, pswd, parm)
-            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%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))
-            raise FetchError(module)
-
-        count = 0
-
-        for file in p4file: 
-            list = file.split()
-
-            if list[2] == "delete":
-                continue
-
-            dest = list[0][len(path)+1:]
-            where = dest.find("#")
-
-            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")
-            raise FetchError(module)
-
-        myret = os.system("tar -czf %s %s" % (ud.localpath, module))
-        if myret != 0:
-            try:
-                os.unlink(ud.localpath)
-            except OSError:
-                pass
-            raise FetchError(module)
-        # cleanup
-        os.system('rm -rf %s' % tmpfile)
-
-
--- a/bitbake-dev/lib/bb/fetch/svk.py
+++ b/bitbake-dev/lib/bb/fetch/svk.py
@@ -1,109 +0,0 @@
-# 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 svk. It is based on the svn implementation
-
-"""
-
-# Copyright (C) 2006 Holger Hans Peter Freyther
-# 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.
-#
-# Based on functions from the base bb module, Copyright 2003 Holger Schurig
-
-import os
-import bb
-from   bb import data
-from   bb.fetch import Fetch
-from   bb.fetch import FetchError
-from   bb.fetch import MissingParameterError
-
-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.
-        """
-        return ud.type in ['svk']
-
-    def localpath(self, url, ud, d):
-        if not "module" in ud.parm:
-            raise MissingParameterError("svk method needs a 'module' parameter")
-        else:
-            ud.module = ud.parm["module"]
-
-        ud.revision = ""
-        if 'rev' in ud.parm:
-            ud.revision = ud.parm['rev']
-
-        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 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" % (ud.date, svkroot, ud.module)
-
-        if ud.revision:
-            svkcmd = "svk co -r %s %s/%s" % (ud.revision, svkroot, ud.module)
-
-        # create temp directory
-        localdata = data.createCopy(d)
-        data.update_data(localdata)
-        bb.msg.debug(2, bb.msg.domain.Fetcher, "Fetch: creating temporary directory")
-        bb.mkdirhier(data.expand('${WORKDIR}', localdata))
-        data.setVar('TMPBASE', data.expand('${WORKDIR}/oesvk.XXXXXX', localdata), localdata)
-        tmppipe = os.popen(data.getVar('MKTEMPDIRCMD', localdata, 1) or "false")
-        tmpfile = tmppipe.readline().strip()
-        if not tmpfile:
-            bb.msg.error(bb.msg.domain.Fetcher, "Fetch: unable to create temporary directory.. make sure 'mktemp' is in the PATH.")
-            raise FetchError(ud.module)
-
-        # check out sources there
-        os.chdir(tmpfile)
-        bb.msg.note(1, bb.msg.domain.Fetcher, "Fetch " + loc)
-        bb.msg.debug(1, bb.msg.domain.Fetcher, "Running %s" % svkcmd)
-        myret = os.system(svkcmd)
-        if myret != 0:
-            try:
-                os.rmdir(tmpfile)
-            except OSError:
-                pass
-            raise FetchError(ud.module)
-
-        os.chdir(os.path.join(tmpfile, os.path.dirname(ud.module)))
-        # 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:
-                os.unlink(ud.localpath)
-            except OSError:
-                pass
-            raise FetchError(ud.module)
-        # cleanup
-        os.system('rm -rf %s' % tmpfile)
--- a/bitbake-dev/lib/bb/fetch/svn.py
+++ b/bitbake-dev/lib/bb/fetch/svn.py
@@ -1,206 +0,0 @@
-# ex:ts=4:sw=4:sts=4:et
-# -*- tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*-
-"""
-BitBake 'Fetch' implementation for svn.
-
-"""
-
-# 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
-# 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 Svn(Fetch):
-    """Class to fetch a module or modules from svn repositories"""
-    def supports(self, url, ud, d):
-        """
-        Check to see if a given url can be fetched with svn.
-        """
-        return ud.type in ['svn']
-
-    def localpath(self, url, ud, d):
-        if not "module" in ud.parm:
-            raise MissingParameterError("svn method needs a 'module' parameter")
-
-        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.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 _buildsvncommand(self, ud, d, command):
-        """
-        Build up an svn commandline based on ud
-        command is "fetch", "update", "info"
-        """
-
-        basecmd = data.expand('${FETCHCMD_svn}', d)
-
-        proto = "svn"
-        if "proto" in ud.parm:
-            proto = ud.parm["proto"]
-
-        svn_rsh = None
-        if proto == "svn+ssh" and "rsh" in ud.parm:
-            svn_rsh = ud.parm["rsh"]
-
-        svnroot = ud.host + ud.path
-
-        # either use the revision, or SRCDATE in braces,
-        options = []
-
-        if ud.user:
-            options.append("--username %s" % ud.user)
-
-        if ud.pswd:
-            options.append("--password %s" % ud.pswd)
-
-        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)
-
-            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)
-
-        return svncmd
-
-    def go(self, loc, ud, d):
-        """Fetch url"""
-
-        # try to use the tarball stash
-        if 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
-
-        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(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(ud.pkgdir)
-            os.chdir(ud.pkgdir)
-            bb.msg.debug(1, bb.msg.domain.Fetcher, "Running %s" % svnfetchcmd)
-            runfetchcmd(svnfetchcmd, d)
-
-        os.chdir(ud.pkgdir)
-        # 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 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-dev/lib/bb/fetch/wget.py
+++ b/bitbake-dev/lib/bb/fetch/wget.py
@@ -1,130 +0,0 @@
-# ex:ts=4:sw=4:sts=4:et
-# -*- tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*-
-"""
-BitBake 'Fetch' implementations
-
-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.
-#
-# Based on functions from the base bb module, Copyright 2003 Holger Schurig
-
-import os
-import bb
-from   bb import data
-from   bb.fetch import Fetch
-from   bb.fetch import FetchError
-from   bb.fetch import uri_replace
-
-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.
-        """
-        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, {}])
-        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, checkonly = False):
-        """Fetch urls"""
-
-        def fetch_uri(uri, ud, d):
-            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)
-
-            uri = uri.split(";")[0]
-            uri_decoded = list(bb.decodeurl(uri))
-            uri_type = uri_decoded[0]
-            uri_host = uri_decoded[1]
-
-            bb.msg.note(1, bb.msg.domain.Fetcher, "fetch " + uri)
-            fetchcmd = fetchcmd.replace("${URI}", uri.split(";")[0])
-            fetchcmd = fetchcmd.replace("${FILE}", ud.basename)
-            httpproxy = None
-            ftpproxy = None
-            if uri_type == 'http':
-                httpproxy = data.getVar("HTTP_PROXY", d, True)
-                httpproxy_ignore = (data.getVar("HTTP_PROXY_IGNORE", d, True) or "").split()
-                for p in httpproxy_ignore:
-                    if uri_host.endswith(p):
-                        httpproxy = None
-                        break
-            if uri_type == 'ftp':
-                ftpproxy = data.getVar("FTP_PROXY", d, True)
-                ftpproxy_ignore = (data.getVar("HTTP_PROXY_IGNORE", d, True) or "").split()
-                for p in ftpproxy_ignore:
-                    if uri_host.endswith(p):
-                        ftpproxy = None
-                        break
-            if httpproxy:
-                fetchcmd = "http_proxy=" + httpproxy + " " + fetchcmd
-            if ftpproxy:
-                fetchcmd = "ftp_proxy=" + ftpproxy + " " + fetchcmd
-            bb.msg.debug(2, bb.msg.domain.Fetcher, "executing " + fetchcmd)
-            ret = os.system(fetchcmd)
-            if ret != 0:
-                return False
-
-            # 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
-
-        localdata = data.createCopy(d)
-        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 True
-
-        if fetch_uri(uri, ud, localdata):
-            return True
-
-        # 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 True
-
-        raise FetchError(uri)
-
-
-    def checkstatus(self, uri, ud, d):
-        return self.go(uri, ud, d, True)
--- a/bitbake-dev/lib/bb/manifest.py
+++ b/bitbake-dev/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-dev/lib/bb/methodpool.py
+++ b/bitbake-dev/lib/bb/methodpool.py
@@ -1,84 +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
-#
-# 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.
-
-
-"""
-    What is a method pool?
-
-    BitBake has a global method scope where .bb, .inc and .bbclass
-    files can install methods. These methods are parsed from strings.
-    To avoid recompiling and executing these string we introduce
-    a method pool to do this task.
-
-    This pool will be used to compile and execute the functions. It
-    will be smart enough to 
-"""
-
-from bb.utils import better_compile, better_exec
-from bb       import error
-
-# A dict of modules we have handled
-# it is the number of .bbclasses + x in size
-_parsed_methods = { }
-_parsed_fns     = { }
-
-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)
-
-    # now some instrumentation
-    code = comp.co_names
-    for name in code:
-        if name in ['None', 'False']:
-            continue
-        elif name in _parsed_fns and not _parsed_fns[name] == modulename:
-            error( "Error Method already seen: %s in' %s' now in '%s'" % (name, _parsed_fns[name], modulename))
-        else:
-            _parsed_fns[name] = modulename
-
-def check_insert_method(modulename, code, fn):
-    """
-    Add the code if it wasnt added before. The module
-    name will be used for that 
-
-    Variables:
-        @modulename a short name e.g. base.bbclass
-        @code The actual python code
-        @fn   The filename from the outer file
-    """
-    if not modulename in _parsed_methods:
-        return insert_method(modulename, code, fn)
-    _parsed_methods[modulename] = 1
-
-def parsed_module(modulename):
-    """
-    Inform me file xyz was parsed
-    """
-    return modulename in _parsed_methods
-
-
-def get_parsed_dict():
-    """
-    shortcut
-    """
-    return _parsed_methods    
--- a/bitbake-dev/lib/bb/msg.py
+++ b/bitbake-dev/lib/bb/msg.py
@@ -1,125 +0,0 @@
-# ex:ts=4:sw=4:sts=4:et
-# -*- tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*-
-"""
-BitBake 'msg' implementation
-
-Message handling infrastructure for bitbake
-
-"""
-
-# Copyright (C) 2006        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 sys, bb
-from bb import event
-
-debug_level = {}
-
-verbose = False
-
-domain = bb.utils.Enum(
-    '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 ):
-        self._message = msg
-        event.Event.__init__(self, d)
-
-class MsgDebug(MsgBase):
-    """Debug Message"""
-
-class MsgNote(MsgBase):
-    """Note Message"""
-
-class MsgWarn(MsgBase):
-    """Warning Message"""
-
-class MsgError(MsgBase):
-    """Error Message"""
-
-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
-
-def set_verbose(level):
-    bb.msg.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:
-            bb.msg.warn(None, "Logging domain %s is not valid, ignoring" % domain)
-
-#
-# Message handling functions
-#
-
-def debug(level, domain, msg, fn = None):
-    if not domain:
-        domain = 'default'
-    if debug_level[domain] >= level:
-        bb.event.fire(MsgDebug(msg, None))
-
-def note(level, domain, msg, fn = None):
-    if not domain:
-        domain = 'default'
-    if level == 1 or verbose or debug_level[domain] >= 1:
-        bb.event.fire(MsgNote(msg, None))
-
-def warn(domain, msg, fn = None):
-    bb.event.fire(MsgWarn(msg, None))
-
-def error(domain, msg, fn = None):
-    bb.event.fire(MsgError(msg, None))
-    print 'ERROR: ' + msg
-
-def fatal(domain, msg, fn = None):
-    bb.event.fire(MsgFatal(msg, None))
-    print 'FATAL: ' + msg
-    sys.exit(1)
-
-def plain(msg, fn = None):
-    bb.event.fire(MsgPlain(msg, None))
-
--- a/bitbake-dev/lib/bb/parse/init.py
+++ b/bitbake-dev/lib/bb/parse/init.py
@@ -1,84 +0,0 @@
-"""
-BitBake Parsers
-
-File parsers for the BitBake build tools.
-
-"""
-
-
-# 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.
-#
-# 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
-
-__all__ = [ 'ParseError', 'SkipPackage', 'cached_mtime', 'mark_dependency',
-            'supports', 'handle', 'init' ]
-handlers = []
-
-import bb, os
-
-class ParseError(Exception):
-    """Exception raised when parsing fails"""
-
-class SkipPackage(Exception):
-    """Exception raised to skip this package"""
-
-__mtime_cache = {}
-def cached_mtime(f):
-    if not __mtime_cache.has_key(f):
-        __mtime_cache[f] = os.stat(f)[8]
-    return __mtime_cache[f]
-
-def cached_mtime_noerror(f):
-    if not __mtime_cache.has_key(f):
-        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)) )
-    bb.data.setVar('__depends', deps, d)
-
-def supports(fn, data):
-    """Returns true if we have a handler for this file, false otherwise"""
-    for h in handlers:
-        if h['supports'](fn, data):
-            return 1
-    return 0
-
-def handle(fn, data, include = 0):
-    """Call the handler that is appropriate for this file"""
-    for h in handlers:
-        if h['supports'](fn, data):
-            return h['handle'](fn, data, include)
-    raise ParseError("%s is not a BitBake file" % fn)
-
-def init(fn, data):
-    for h in handlers:
-        if h['supports'](fn):
-            return h['init'](data)
-
-
-from parse_py import __version__, ConfHandler, BBHandler
--- a/bitbake-dev/lib/bb/parse/parse_py/BBHandler.py
+++ b/bitbake-dev/lib/bb/parse/parse_py/BBHandler.py
@@ -1,401 +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 -*-
-"""
-   class for handling .bb files
-
-   Reads a .bb file and obtains its metadata
-
-"""
-
-
-#  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.
-#
-# 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 re, bb, os, sys, time, string
-import bb.fetch, bb.build, bb.utils
-from bb import data, fetch, methodpool
-
-from ConfHandler import include, localpath, obtain, init
-from bb.parse import ParseError
-
-__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+(.+)" )
-__export_func_regexp__   = re.compile( r"EXPORT_FUNCTIONS\s+(.+)" )
-__addtask_regexp__       = re.compile("addtask\s+(?P<func>\w+)\s*((before\s*(?P<before>((.*(?=after))|(.*))))|(after\s*(?P<after>((.*(?=before))|(.*)))))*")
-__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
-__body__   = []
-__classname__ = ""
-classes = [ None, ]
-
-# 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
-#
-# 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"
-
-def inherit(files, d):
-    __inherit_cache = data.getVar('__inherit_cache', d) or []
-    fn = ""
-    lineno = 0
-    files = data.expand(files, d)
-    for file in files:
-        if file[0] != "/" and file[-8:] != ".bbclass":
-            file = os.path.join('classes', '%s.bbclass' % file)
-
-        if not file in __inherit_cache:
-            bb.msg.debug(2, bb.msg.domain.Parsing, "BB %s:%d: inheriting %s" % (fn, lineno, file))
-            __inherit_cache.append( file )
-            data.setVar('__inherit_cache', __inherit_cache, d)
-            include(fn, file, d, "inherit")
-            __inherit_cache = data.getVar('__inherit_cache', d) or []
-
-
-def finalise(fn, d):
-    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}/anonfunc/', d)
-        anonfuncs = data.getVar('__BBANONFUNCS', d) or []
-        code = ""
-        for f in anonfuncs:
-            code = code + "    %s(d)\n" % f
-        data.setVar("__anonfunc", code, 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, "Exception when executing anonymous function: %s" % e)
-        raise
-    data.delVar("__anonqueue", d)
-    data.delVar("__anonfunc", d)
-    data.update_data(d)
-
-    all_handlers = {} 
-    for var in data.getVar('__BBHANDLERS', d) or []:
-        # try to add the handler
-        handler = data.getVar(var,d)
-        bb.event.register(var, handler)
-
-    tasklist = data.getVar('__BBTASKS', d) or []
-    bb.build.add_tasks(tasklist, d)
-
-    bb.event.fire(bb.event.RecipeParsed(fn, d))
-
-
-def handle(fn, d, include = 0):
-    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)
-    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 %s not found" % fn)
-    else:
-        f = open(fn,'r')
-        abs_fn = fn
-
-    if include:
-        bb.parse.mark_dependency(d, abs_fn)
-
-    if ext != ".bbclass":
-        data.setVar('FILE', fn, 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)
-    if ext == ".bbclass":
-        classes.remove(__classname__)
-    else:
-        if include == 0:
-            multi = data.getVar('BBCLASSEXTEND', d, 1)
-            if multi:
-                based = bb.data.createCopy(d)
-                finalise(fn, based)
-                darray = {"": based}
-                for cls in multi.split():
-                    pn = data.getVar('PN', d, True)
-                    based = bb.data.createCopy(d)
-                    data.setVar('PN', pn + '-' + cls, based)
-                    inherit([cls], based)
-                    finalise(fn, based)
-                    darray[cls] = based
-                return darray
-            else:
-                finalise(fn, 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
-
-    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__
-    if __infunc__:
-        if s == '}':
-            __body__.append('')
-            if __infunc__ == "__anonymous":
-                funcname = ("__anon_%s_%s" % (lineno, fn.translate(string.maketrans('/.+-', '____'))))
-                if not funcname in methodpool._parsed_fns:
-                    text = "def %s(d):\n" % (funcname) + '\n'.join(__body__)
-                    methodpool.insert_method(funcname, text, fn)
-                anonfuncs = data.getVar('__BBANONFUNCS', d) or []
-                anonfuncs.append(funcname)
-                data.setVar('__BBANONFUNCS', anonfuncs, d)
-            else:
-                data.setVarFlag(__infunc__, "func", 1, d)
-                data.setVar(__infunc__, '\n'.join(__body__), d)
-            __infunc__ = ""
-            __body__ = []
-        else:
-            __body__.append(s)
-        return
-
-    if __inpython__:
-        m = __python_func_regexp__.match(s)
-        if m and lineno != IN_PYTHON_EOF:
-            __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 )
-            __body__ = []
-            __inpython__ = False
-
-            if lineno == IN_PYTHON_EOF:
-                return
-
-#           fall through
-
-    if s == '' or s[0] == '#': return          # skip comments and empty lines
-
-    if s[-1] == '\\':
-        __residue__.append(s[:-1])
-        return
-
-    s = "".join(__residue__) + s
-    __residue__ = []
-
-    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)
-        return
-
-    m = __def_regexp__.match(s)
-    if m:
-        __body__.append(s)
-        __inpython__ = True
-        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)
-
-        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 []
-        if not var in bbtasks:
-            bbtasks.append(var)
-        data.setVar('__BBTASKS', bbtasks, d)
-
-        existing = data.getVarFlag(var, "deps", d) or []
-        if after is not None:
-            # set up deps for function
-            for entry in after.split():
-                if entry not in existing:
-                    existing.append(entry)
-        data.setVarFlag(var, "deps", existing, d)
-        if before is not None:
-            # set up things that depend on this func
-            for entry in before.split():
-                existing = data.getVarFlag(entry, "deps", d) or []
-                if var not in existing:
-                    data.setVarFlag(entry, "deps", [var] + existing, d)
-        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)
-        return
-
-    m = __inherit_regexp__.match(s)
-    if m:
-
-        files = m.group(1)
-        n = __word__.findall(files)
-        inherit(n, d)
-        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
-
-# Add us to the handlers list
-from bb.parse import handlers
-handlers.append({'supports': supports, 'handle': handle, 'init': init})
-del handlers
--- a/bitbake-dev/lib/bb/parse/parse_py/ConfHandler.py
+++ b/bitbake-dev/lib/bb/parse/parse_py/ConfHandler.py
@@ -1,234 +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 -*-
-"""
-   class for handling configuration data files
-
-   Reads a .conf file and obtains its metadata
-
-"""
-
-# 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.
-#
-# 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 re, bb.data, os, sys
-from bb.parse import ParseError
-
-#__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)$")
-__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):
-        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
-
-    if "://" not in fn:
-        return fn
-
-    localfn = None
-    try:
-        localfn = bb.fetch.localpath(fn, d, False)
-    except bb.MalformedUrl:
-        pass
-
-    if not localfn:
-        return 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], data)
-        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
-
-
-def include(oldfn, fn, data, error_out):
-    """
-
-    error_out If True a ParseError will be reaised if the to be included
-    """
-    if oldfn == fn: # prevent infinate recursion
-        return None
-
-    import bb
-    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.which(bbpath, fn)
-        if abs_fn:
-            fn = abs_fn
-
-    from bb.parse import handle
-    try:
-        ret = handle(fn, data, True)
-    except IOError:
-        if 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"
-    init(data)
-
-    if include == 0:
-        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
-
-    if include:
-        bb.parse.mark_dependency(data, abs_fn)
-
-    lineno = 0
-    bb.data.setVar('FILE', fn, data)
-    while 1:
-        lineno = lineno + 1
-        s = f.readline()
-        if not s: break
-        w = s.strip()
-        if not w: continue          # skip empty lines
-        s = s.rstrip()
-        if s[0] == '#': continue    # skip comments
-        while s[-1] == '\\':
-            s2 = f.readline()[:-1].strip()
-            lineno = lineno + 1
-            s = s[:-1] + s2
-        feeder(lineno, s, fn, 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)
-
-    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:
-            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" % ((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)
-        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)
-        return
-
-    m = __require_regexp__.match(s)
-    if m:
-        s = bb.data.expand(m.group(1), data)
-        include(fn, s, data, "include required")
-        return
-
-    m = __export_regexp__.match(s)
-    if m:
-        bb.data.setVarFlag(m.group(1), "export", 1, data)
-        return
-
-    raise ParseError("%s:%d: unparsed line: '%s'" % (fn, lineno, s));
-
-# Add us to the handlers list
-from bb.parse import handlers
-handlers.append({'supports': supports, 'handle': handle, 'init': init})
-del handlers
--- a/bitbake-dev/lib/bb/parse/parse_py/init.py
+++ b/bitbake-dev/lib/bb/parse/parse_py/init.py
@@ -1,33 +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 -*-
-"""
-BitBake Parsers
-
-File parsers for the BitBake build tools.
-
-"""
-
-# 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.
-#
-# 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
-__version__ = '1.0'
-
-__all__ = [ 'ConfHandler', 'BBHandler']
-
-import ConfHandler
-import BBHandler
--- a/bitbake-dev/lib/bb/persist_data.py
+++ b/bitbake-dev/lib/bb/persist_data.py
@@ -1,121 +0,0 @@
-# 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
-
-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):
-        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.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)
-
-        self.connection = sqlite3.connect(self.cachefile, timeout=5, isolation_level=None)
-
-    def addDomain(self, domain):
-        """
-        Should be called before any domain is used
-        Creates it if it doesn't exist.
-        """
-        self.connection.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.connection.execute("DROP TABLE IF EXISTS %s;" % domain)
-
-    def getKeyValues(self, domain):
-        """
-        Return a list of key + value pairs for a domain
-        """
-        ret = {}
-        data = self.connection.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.connection.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.connection.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])
-
-    def _execute(self, *query):
-        while True:	
-            try:
-                self.connection.execute(*query)
-                return
-            except sqlite3.OperationalError, e:
-                if 'database is locked' in str(e):
-                    continue
-                raise
-        
-        
-
--- a/bitbake-dev/lib/bb/providers.py
+++ b/bitbake-dev/lib/bb/providers.py
@@ -1,315 +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
-# Copyright (C) 2003, 2004  Phil Blundell
-# Copyright (C) 2003 - 2005 Michael 'Mickey' Lauer
-# Copyright (C) 2005        Holger Hans Peter Freyther
-# Copyright (C) 2005        ROAD GmbH
-# Copyright (C) 2006        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 re
-from bb import data, utils
-import bb
-
-class NoProvider(Exception):
-    """Exception raised when no provider of a build dependency can be found"""
-
-class NoRProvider(Exception):
-    """Exception raised when no provider of a runtime dependency can be found"""
-
-
-def sortPriorities(pn, dataCache, pkg_pn = None):
-    """
-    Reorder pkg_pn by file priority and default preference
-    """
-
-    if not pkg_pn:
-        pkg_pn = dataCache.pkg_pn
-
-    files = pkg_pn[pn]
-    priorities = {}
-    for f in files:
-        priority = dataCache.bbfile_priority[f]
-        preference = dataCache.pkg_dp[f]
-        if priority not in priorities:
-            priorities[priority] = {}
-        if preference not in priorities[priority]:
-            priorities[priority][preference] = []
-        priorities[priority][preference].append(f)
-    pri_list = priorities.keys()
-    pri_list.sort(lambda a, b: a - b)
-    tmp_pn = []
-    for pri in pri_list:
-        pref_list = priorities[pri].keys()
-        pref_list.sort(lambda a, b: b - a)
-        tmp_pref = []
-        for pref in pref_list:
-            tmp_pref.extend(priorities[pri][pref])
-        tmp_pn = [tmp_pref] + tmp_pn
-
-    return tmp_pn
-
-
-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', "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)
-    if preferred_v:
-        m = re.match('(\d+:)*(.*)(_.*)*', preferred_v)
-        if m:
-            if m.group(1):
-                preferred_e = int(m.group(1)[:-1])
-            else:
-                preferred_e = None
-            preferred_v = m.group(2)
-            if m.group(3):
-                preferred_r = m.group(3)[1:]
-            else:
-                preferred_r = None
-        else:
-            preferred_e = None
-            preferred_r = None
-
-        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):
-                    preferred_file = f
-                    preferred_ver = (pe, pv, pr)
-                    break
-            if preferred_file:
-                break;
-        if preferred_r:
-            pv_str = '%s-%s' % (preferred_v, preferred_r)
-        else:
-            pv_str = preferred_v
-        if not (preferred_e is None):
-            pv_str = '%s:%s' % (preferred_e, pv_str)
-        itemstr = ""
-        if item:
-            itemstr = " (for item %s)" % item
-        if preferred_file is None:
-            bb.msg.note(1, bb.msg.domain.Provider, "preferred version %s of %s not available%s" % (pv_str, pn, itemstr))
-        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))
-
-    return (preferred_ver, preferred_file)
-
-
-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 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)
-
-
-def _filterProviders(providers, item, cfgData, dataCache):
-    """
-    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 = {}
-    for p in providers:
-        pn = dataCache.pkg_fn[p]
-        if pn not in pkg_pn:
-            pkg_pn[pn] = []
-        pkg_pn[pn].append(p)
-
-    bb.msg.debug(1, bb.msg.domain.Provider, "providers for %s are: %s" % (item, pkg_pn.keys()))
-
-    # First add PREFERRED_VERSIONS
-    for pn in pkg_pn.keys():
-        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 verisons
-    for pn in pkg_pn.keys():
-        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:
-        pn = dataCache.pkg_fn[p]
-        if pn != item:
-            continue
-        (newvers, fn) = preferred_versions[pn]
-        if not fn in eligible:
-            continue
-        eligible.remove(fn)
-        eligible = [fn] + eligible
-
-    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
-    """
-    rproviders = []
-
-    if rdepend in dataCache.rproviders:
-       rproviders += dataCache.rproviders[rdepend]
-
-    if rdepend in dataCache.packages:
-        rproviders += dataCache.packages[rdepend]
-
-    if rproviders:
-        return rproviders
-
-    # Only search dynamic packages if we can't find anything in other variables
-    for pattern in dataCache.packages_dynamic:
-        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]
-
-    return rproviders
--- a/bitbake-dev/lib/bb/runqueue.py
+++ b/bitbake-dev/lib/bb/runqueue.py
--- a/bitbake-dev/lib/bb/shell.py
+++ b/bitbake-dev/lib/bb/shell.py
@@ -1,824 +0,0 @@
-# ex:ts=4:sw=4:sts=4:et
-# -*- tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*-
-##########################################################################
-#
-# Copyright (C) 2005-2006 Michael 'Mickey' Lauer <mickey@Vanille.de>
-# Copyright (C) 2005-2006 Vanille Media
-#
-# 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.
-#
-##########################################################################
-#
-# Thanks to:
-# * Holger Freyther <zecke@handhelds.org>
-# * Justin Patrin <papercrane@reversefold.com>
-#
-##########################################################################
-
-"""
-BitBake Shell
-
-IDEAS:
-    * list defined tasks per package
-    * list classes
-    * toggle force
-    * command to reparse just one (or more) bbfile(s)
-    * automatic check if reparsing is necessary (inotify?)
-    * frontend for bb file manipulation
-    * more shell-like features:
-        - output control, i.e. pipe output into grep, sort, etc.
-        - job control, i.e. bring running commands into background and foreground
-    * start parsing in background right after startup
-    * ncurses interface
-
-PROBLEMS:
-    * force doesn't always work
-    * readline completion for commands with more than one parameters
-
-"""
-
-##########################################################################
-# Import and setup global variables
-##########################################################################
-
-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
-
-__version__ = "0.5.3.1"
-__credits__ = """BitBake Shell Version %s (C) 2005 Michael 'Mickey' Lauer <mickey@Vanille.de>
-Type 'help' for more information, press CTRL-D to exit.""" % __version__
-
-cmds = {}
-leave_mainloop = False
-last_exception = None
-cooker = None
-parsed = False
-debug = os.environ.get( "BBSHELL_DEBUG", "" )
-
-##########################################################################
-# Class BitBakeShellCommands
-##########################################################################
-
-class BitBakeShellCommands:
-    """This class contains the valid commands for the shell"""
-
-    def __init__( self, shell ):
-        """Register all the commands"""
-        self._shell = shell
-        for attr in BitBakeShellCommands.__dict__:
-            if not attr.startswith( "_" ):
-                if attr.endswith( "_" ):
-                    command = attr[:-1].lower()
-                else:
-                    command = attr[:].lower()
-                method = getattr( BitBakeShellCommands, attr )
-                debugOut( "registering command '%s'" % command )
-                # scan number of arguments
-                usage = getattr( method, "usage", "" )
-                if usage != "<...>":
-                    numArgs = len( usage.split() )
-                else:
-                    numArgs = -1
-                shell.registerCommand( command, method, numArgs, "%s %s" % ( command, usage ), method.__doc__ )
-
-    def _checkParsed( self ):
-        if not parsed:
-            print "SHELL: This command needs to parse bbfiles..."
-            self.parse( None )
-
-    def _findProvider( self, item ):
-        self._checkParsed()
-        # Need to use taskData for this information
-        preferred = data.getVar( "PREFERRED_PROVIDER_%s" % item, cooker.configuration.data, 1 )
-        if not preferred: preferred = item
-        try:
-            lv, lf, pv, pf = Providers.findBestProvider(preferred, cooker.configuration.data, cooker.status)
-        except KeyError:
-            if item in cooker.status.providers:
-                pf = cooker.status.providers[item][0]
-            else:
-                pf = None
-        return pf
-
-    def alias( self, params ):
-        """Register a new name for a command"""
-        new, old = params
-        if not old in cmds:
-            print "ERROR: Command '%s' not known" % old
-        else:
-            cmds[new] = cmds[old]
-            print "OK"
-    alias.usage = "<alias> <command>"
-
-    def buffer( self, params ):
-        """Dump specified output buffer"""
-        index = params[0]
-        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."
-        else:
-            print "="*35, "Available Output Buffers", "="*27
-            for index, cmd in enumerate( commands ):
-                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 )
-        if len( names ) == 0: names = [ globexpr ]
-        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(localdata, cooker.status, name)
-                providers = td.get_provider(name)
-
-                if len(providers) == 0:
-                    raise Providers.NoProvider
-
-                tasks.append([name, "do_%s" % cmd])
-
-            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"
-            last_exception = Providers.NoProvider
-
-        except runqueue.TaskFailure, fnids:
-            for fnid in fnids:
-                print "ERROR: '%s' failed" % td.fn_index[fnid]
-            last_exception = runqueue.TaskFailure
-
-        except build.EventException, e:
-            print "ERROR: Couldn't build '%s'" % names
-            last_exception = e
-
-
-    build.usage = "<providee>"
-
-    def clean( self, params ):
-        """Clean a providee"""
-        self.build( params, "clean" )
-    clean.usage = "<providee>"
-
-    def compile( self, params ):
-        """Execute 'compile' on a providee"""
-        self.build( params, "compile" )
-    compile.usage = "<providee>"
-
-    def configure( self, params ):
-        """Execute 'configure' on a providee"""
-        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]
-        bbfile = self._findProvider( name )
-        if bbfile is not None:
-            os.system( "%s %s" % ( os.environ.get( "EDITOR", "vi" ), bbfile ) )
-        else:
-            print "ERROR: Nothing provides '%s'" % name
-    edit.usage = "<providee>"
-
-    def environment( self, params ):
-        """Dump out the outer BitBake environment"""
-        cooker.showEnvironment()
-
-    def exit_( self, params ):
-        """Leave the BitBake Shell"""
-        debugOut( "setting leave_mainloop to true" )
-        global leave_mainloop
-        leave_mainloop = True
-
-    def fetch( self, params ):
-        """Fetch a providee"""
-        self.build( params, "fetch" )
-    fetch.usage = "<providee>"
-
-    def fileBuild( self, params, cmd = "build" ):
-        """Parse and build a .bb file"""
-        global last_exception
-        name = params[0]
-        bf = completeFilePath( name )
-        print "SHELL: Calling '%s' on '%s'" % ( cmd, bf )
-
-        try:
-            cooker.buildFile(bf, cmd)
-        except parse.ParseError:
-            print "ERROR: Unable to open or parse '%s'" % bf
-        except build.EventException, e:
-            print "ERROR: Couldn't build '%s'" % name
-            last_exception = e
-
-    fileBuild.usage = "<bbfile>"
-
-    def fileClean( self, params ):
-        """Clean a .bb file"""
-        self.fileBuild( params, "clean" )
-    fileClean.usage = "<bbfile>"
-
-    def fileEdit( self, params ):
-        """Call $EDITOR on a .bb file"""
-        name = params[0]
-        os.system( "%s %s" % ( os.environ.get( "EDITOR", "vi" ), completeFilePath( name ) ) )
-    fileEdit.usage = "<bbfile>"
-
-    def fileRebuild( self, params ):
-        """Rebuild (clean & build) a .bb file"""
-        self.fileBuild( params, "rebuild" )
-    fileRebuild.usage = "<bbfile>"
-
-    def fileReparse( self, params ):
-        """(re)Parse a bb file"""
-        bbfile = params[0]
-        print "SHELL: Parsing '%s'" % bbfile
-        parse.update_mtime( bbfile )
-        cooker.bb_cache.cacheValidUpdate(bbfile)
-        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"
-        else:
-            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 )
-
-    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 )
-
-    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
-
-    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)..."
-        else:
-            reason, event = last_exception.args
-            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:"
-                try:
-                    print open( filename ).read()
-                except IOError:
-                    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
-        elif what == "providers":
-            self._checkParsed()
-            for key in globfilter( cooker.status.pkg_pn.keys(), globexpr ): print key
-        else:
-            print "Usage: match %s" % self.print_.usage
-    match.usage = "<files|providers> <glob>"
-
-    def new( self, params ):
-        """Create a new .bb file and open the editor"""
-        dirname, filename = params
-        packages = '/'.join( data.getVar( "BBFILES", cooker.configuration.data, 1 ).split('/')[:-2] )
-        fulldirname = "%s/%s" % ( packages, dirname )
-
-        if not os.path.exists( 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 )
-                return False
-            print "SHELL: Creating '%s/%s'" % ( fulldirname, filename )
-            newpackage = open( "%s/%s" % ( fulldirname, filename ), "w" )
-            print >>newpackage,"""DESCRIPTION = ""
-SECTION = ""
-AUTHOR = ""
-HOMEPAGE = ""
-MAINTAINER = ""
-LICENSE = "GPL"
-PR = "r0"
-
-SRC_URI = ""
-
-#inherit base
-
-#do_configure() {
-#
-#}
-
-#do_compile() {
-#
-#}
-
-#do_stage() {
-#
-#}
-
-#do_install() {
-#
-#}
-"""
-            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]
-        contents = self._shell.myout.buffer( int( index ) )
-        sendToPastebin( "output of " + params[0], contents )
-    pasteBin.usage = "<index>"
-
-    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)..."
-        else:
-            reason, event = last_exception.args
-            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..."
-
-                file = open( filename ).read()
-                sendToPastebin( "contents of " + filename, file )
-
-    def patch( self, params ):
-        """Execute 'patch' command on a providee"""
-        self.build( params, "patch" )
-    patch.usage = "<providee>"
-
-    def parse( self, params ):
-        """(Re-)parse .bb files and calculate the dependency graph"""
-        cooker.status = cache.CacheData()
-        ignore = data.getVar("ASSUME_PROVIDED", cooker.configuration.data, 1) or ""
-        cooker.status.ignored_dependencies = set( ignore.split() )
-        cooker.handleCollections( data.getVar("BBFILE_COLLECTIONS", cooker.configuration.data, 1) )
-
-        (filelist, masked) = cooker.collect_bbfiles()
-        cooker.parse_bbfiles(filelist, masked, cooker.myProgressCallback)
-        cooker.buildDepgraph()
-        global parsed
-        parsed = True
-        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] )
-            self.fileReparse( [ bbfile ] )
-        else:
-            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
-    getvar.usage = "<variable>"
-
-    def peek( self, params ):
-        """Dump contents of variable defined in providee's metadata"""
-        name, var = params
-        bbfile = self._findProvider( name )
-        if bbfile is not None:
-            the_data = cooker.bb_cache.loadDataFull(bbfile, cooker.configuration.data)
-            value = the_data.getVar( var, 1 )
-            print value
-        else:
-            print "ERROR: Nothing provides '%s'" % name
-    peek.usage = "<providee> <variable>"
-
-    def poke( self, params ):
-        """Set contents of variable defined in providee's metadata"""
-        name, var, value = params
-        bbfile = self._findProvider( name )
-        if bbfile is not None:
-            print "ERROR: Sorry, this functionality is currently broken"
-            #d = cooker.pkgdata[bbfile]
-            #data.setVar( var, value, d )
-
-            # mark the change semi persistant
-            #cooker.pkgdata.setDirty(bbfile, d)
-            #print "OK"
-        else:
-            print "ERROR: Nothing provides '%s'" % name
-    poke.usage = "<providee> <variable> <value>"
-
-    def print_( self, params ):
-        """Dump all files or providers"""
-        what = params[0]
-        if what == "files":
-            self._checkParsed()
-            for key in cooker.status.pkg_fn.keys(): print key
-        elif what == "providers":
-            self._checkParsed()
-            for key in cooker.status.providers.keys(): print key
-        else:
-            print "Usage: print %s" % self.print_.usage
-    print_.usage = "<files|providers>"
-
-    def python( self, params ):
-        """Enter the expert mode - an interactive BitBake Python Interpreter"""
-        sys.ps1 = "EXPERT BB>>> "
-        sys.ps2 = "EXPERT BB... "
-        import code
-        interpreter = code.InteractiveConsole( dict( globals() ) )
-        interpreter.interact( "SHELL: Expert Mode - BitBake Python %s\nType 'help' for more information, press CTRL-D to switch back to BBSHELL." % sys.version )
-
-    def showdata( self, params ):
-        """Execute 'showdata' on a providee"""
-        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"
-    setVar.usage = "<variable> <value>"
-
-    def rebuild( self, params ):
-        """Clean and rebuild a .bb file or a providee"""
-        self.build( params, "clean" )
-        self.build( params, "build" )
-    rebuild.usage = "<providee>"
-
-    def shell( self, params ):
-        """Execute a shell command and dump the output"""
-        if params != "":
-            print commands.getoutput( " ".join( params ) )
-    shell.usage = "<...>"
-
-    def stage( self, params ):
-        """Execute 'stage' on a providee"""
-        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
-
-    def test( self, params ):
-        """<just for testing>"""
-        print "testCommand called with '%s'" % params
-
-    def unpack( self, params ):
-        """Execute 'unpack' on a providee"""
-        self.build( params, "unpack" )
-    unpack.usage = "<providee>"
-
-    def which( self, params ):
-        """Computes the providers for a given providee"""
-        # Need to use taskData for this information
-        item = params[0]
-
-        self._checkParsed()
-
-        preferred = data.getVar( "PREFERRED_PROVIDER_%s" % item, cooker.configuration.data, 1 )
-        if not preferred: preferred = item
-
-        try:
-            lv, lf, pv, pf = Providers.findBestProvider(preferred, cooker.configuration.data, cooker.status)
-        except KeyError:
-            lv, lf, pv, pf = (None,)*4
-
-        try:
-            providers = cooker.status.providers[item]
-        except KeyError:
-            print "SHELL: ERROR: Nothing provides", preferred
-        else:
-            for provider in providers:
-                if provider == pf: provider = " (***) %s" % provider
-                else:              provider = "       %s" % provider
-                print provider
-    which.usage = "<providee>"
-
-##########################################################################
-# Common helper functions
-##########################################################################
-
-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():
-        if key.endswith( bbfile ):
-            return key
-    return bbfile
-
-def sendToPastebin( desc, content ):
-    """Send content to http://oe.pastebin.com"""
-    mydata = {}
-    mydata["lang"] = "Plain Text"
-    mydata["desc"] = desc
-    mydata["cvt_tabs"] = "No"
-    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"}
-
-    host = "rafb.net"
-    conn = httplib.HTTPConnection( "%s:80" % host )
-    conn.request("POST", "/paste/paste.php", params, headers )
-
-    response = conn.getresponse()
-    conn.close()
-
-    if response.status == 302:
-        location = response.getheader( "location" ) or "unknown"
-        print "SHELL: Pasted to http://%s%s" % ( host, location )
-    else:
-        print "ERROR: %s %s" % ( response.status, response.reason )
-
-def completer( text, state ):
-    """Return a possible readline completion"""
-    debugOut( "completer called with text='%s', state='%d'" % ( text, state ) )
-
-    if state == 0:
-        line = readline.get_line_buffer()
-        if " " in line:
-            line = line.split()
-            # we are in second (or more) argument
-            if line[0] in cmds and hasattr( cmds[line[0]][0], "usage" ): # known command and usage
-                u = getattr( cmds[line[0]][0], "usage" ).split()[0]
-                if u == "<variable>":
-                    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() ]
-                elif u == "<providee>":
-                    if cooker.status.pkg_fn is None: allmatches = [ "(No Matches Available. Parsed yet?)" ]
-                    else: allmatches = cooker.status.providers.iterkeys()
-                else: allmatches = [ "(No tab completion available for this command)" ]
-            else: allmatches = [ "(No tab completion available for this command)" ]
-        else:
-            # we are in first argument
-            allmatches = cmds.iterkeys()
-
-        completer.matches = [ x for x in allmatches if x[:len(text)] == text ]
-        #print "completer.matches = '%s'" % completer.matches
-    if len( completer.matches ) > state:
-        return completer.matches[state]
-    else:
-        return None
-
-def debugOut( text ):
-    if debug:
-        sys.stderr.write( "( %s )\n" % text )
-
-def columnize( alist, width = 80 ):
-    """
-    A word-wrap function that preserves existing line breaks
-    and most spaces in the text. Expects that existing line
-    breaks are posix newlines (\n).
-    """
-    return reduce(lambda line, word, width=width: '%s%s%s' %
-                  (line,
-                   ' \n'[(len(line[line.rfind('\n')+1:])
-                         + len(word.split('\n',1)[0]
-                              ) >= width)],
-                   word),
-                  alist
-                 )
-
-def globfilter( names, pattern ):
-    return fnmatch.filter( names, pattern )
-
-##########################################################################
-# Class MemoryOutput
-##########################################################################
-
-class MemoryOutput:
-    """File-like output class buffering the output of the last 10 commands"""
-    def __init__( self, delegate ):
-        self.delegate = delegate
-        self._buffer = []
-        self.text = []
-        self._command = None
-
-    def startCommand( self, command ):
-        self._command = command
-        self.text = []
-    def endCommand( self ):
-        if self._command is not None:
-            if len( self._buffer ) == 10: del self._buffer[0]
-            self._buffer.append( ( self._command, self.text ) )
-    def removeLast( self ):
-        if self._buffer:
-            del self._buffer[ len( self._buffer ) - 1 ]
-        self.text = []
-        self._command = None
-    def lastBuffer( self ):
-        if self._buffer:
-            return self._buffer[ len( self._buffer ) -1 ][1]
-    def bufferedCommands( self ):
-        return [ cmd for cmd, output in self._buffer ]
-    def buffer( self, i ):
-        if i < len( self._buffer ):
-            return "BB>> %s\n%s" % ( self._buffer[i][0], "".join( self._buffer[i][1] ) )
-        else: return "ERROR: Invalid buffer number. Buffer needs to be in (0, %d)" % ( len( self._buffer ) - 1 )
-    def write( self, text ):
-        if self._command is not None and text != "BB>> ": self.text.append( text )
-        if self.delegate is not None: self.delegate.write( text )
-    def flush( self ):
-        return self.delegate.flush()
-    def fileno( self ):
-        return self.delegate.fileno()
-    def isatty( self ):
-        return self.delegate.isatty()
-
-##########################################################################
-# Class BitBakeShell
-##########################################################################
-
-class BitBakeShell:
-
-    def __init__( self ):
-        """Register commands and set up readline"""
-        self.commandQ = Queue.Queue()
-        self.commands = BitBakeShellCommands( self )
-        self.myout = MemoryOutput( sys.stdout )
-        self.historyfilename = os.path.expanduser( "~/.bbsh_history" )
-        self.startupfilename = os.path.expanduser( "~/.bbsh_startup" )
-
-        readline.set_completer( completer )
-        readline.set_completer_delims( " " )
-        readline.parse_and_bind("tab: complete")
-
-        try:
-            readline.read_history_file( self.historyfilename )
-        except IOError:
-            pass  # It doesn't exist yet.
-
-        print __credits__
-
-    def cleanup( self ):
-        """Write readline history and clean up resources"""
-        debugOut( "writing command history" )
-        try:
-            readline.write_history_file( self.historyfilename )
-        except:
-            print "SHELL: Unable to save command history"
-
-    def registerCommand( self, command, function, numparams = 0, usage = "", helptext = "" ):
-        """Register a command"""
-        if usage == "": usage = command
-        if helptext == "": helptext = function.__doc__ or "<not yet documented>"
-        cmds[command] = ( function, numparams, usage, helptext )
-
-    def processCommand( self, command, params ):
-        """Process a command. Check number of params and print a usage string, if appropriate"""
-        debugOut( "processing command '%s'..." % command )
-        try:
-            function, numparams, usage, helptext = cmds[command]
-        except KeyError:
-            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
-                return
-
-            result = function( self.commands, params )
-            debugOut( "result was '%s'" % result )
-
-    def processStartupFile( self ):
-        """Read and execute all commands found in $HOME/.bbsh_startup"""
-        if os.path.exists( self.startupfilename ):
-            startupfile = open( self.startupfilename, "r" )
-            for cmdline in startupfile:
-                debugOut( "processing startup line '%s'" % cmdline )
-                if not cmdline:
-                    continue
-                if "|" in cmdline:
-                    print "ERROR: '|' in startup file is not allowed. Ignoring line"
-                    continue
-                self.commandQ.put( cmdline.strip() )
-
-    def main( self ):
-        """The main command loop"""
-        while not leave_mainloop:
-            try:
-                if self.commandQ.empty():
-                    sys.stdout = self.myout.delegate
-                    cmdline = raw_input( "BB>> " )
-                    sys.stdout = self.myout
-                else:
-                    cmdline = self.commandQ.get()
-                if cmdline:
-                    allCommands = cmdline.split( ';' )
-                    for command in allCommands:
-                        pipecmd = None
-                        #
-                        # special case for expert mode
-                        if command == 'python':
-                            sys.stdout = self.myout.delegate
-                            self.processCommand( command, "" )
-                            sys.stdout = self.myout
-                        else:
-                            self.myout.startCommand( command )
-                            if '|' in command: # disable output
-                                command, pipecmd = command.split( '|' )
-                                delegate = self.myout.delegate
-                                self.myout.delegate = None
-                            tokens = shlex.split( command, True )
-                            self.processCommand( tokens[0], tokens[1:] or "" )
-                            self.myout.endCommand()
-                            if pipecmd is not None: # restore output
-                                self.myout.delegate = delegate
-
-                                pipe = popen2.Popen4( pipecmd )
-                                pipe.tochild.write( "\n".join( self.myout.lastBuffer() ) )
-                                pipe.tochild.close()
-                                sys.stdout.write( pipe.fromchild.read() )
-                        #
-            except EOFError:
-                print
-                return
-            except KeyboardInterrupt:
-                print
-
-##########################################################################
-# Start function - called from the BitBake command line utility
-##########################################################################
-
-def start( aCooker ):
-    global cooker
-    cooker = aCooker
-    bbshell = BitBakeShell()
-    bbshell.processStartupFile()
-    bbshell.main()
-    bbshell.cleanup()
-
-if __name__ == "__main__":
-    print "SHELL: Sorry, this program should only be called by BitBake."
--- a/bitbake-dev/lib/bb/taskdata.py
+++ b/bitbake-dev/lib/bb/taskdata.py
@@ -1,595 +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 -*-
-"""
-BitBake 'TaskData' implementation
-
-Task data collection and handling
-
-"""
-
-# Copyright (C) 2006  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
-
-class TaskData:
-    """
-    BitBake Task Data implementation
-    """
-    def __init__(self, abort = True, tryaltconfigs = False):
-        self.build_names_index = []
-        self.run_names_index = []
-        self.fn_index = []
-
-        self.build_targets = {}
-        self.run_targets = {}
-
-        self.external_targets = []
-
-        self.tasks_fnid = []
-        self.tasks_name = []
-        self.tasks_tdepends = []
-        self.tasks_idepends = []
-        # Cache to speed up task ID lookups
-        self.tasks_lookup = {}
-
-        self.depids = {}
-        self.rdepids = {}
-
-        self.consider_msgs_cache = []
-
-        self.failed_deps = []
-        self.failed_rdeps = []
-        self.failed_fnids = []
-
-        self.abort = abort
-        self.tryaltconfigs = tryaltconfigs
-
-    def getbuild_id(self, name):
-        """
-        Return an ID number for the build target name.
-        If it doesn't exist, create one.
-        """
-        if not name in self.build_names_index:
-            self.build_names_index.append(name)
-            return len(self.build_names_index) - 1
-
-        return self.build_names_index.index(name)
-
-    def getrun_id(self, 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:
-            self.run_names_index.append(name)
-            return len(self.run_names_index) - 1
-
-        return self.run_names_index.index(name)
-
-    def getfn_id(self, name):
-        """
-        Return an ID number for the filename. 
-        If it doesn't exist, create one.
-        """
-        if not name in self.fn_index:
-            self.fn_index.append(name)
-            return len(self.fn_index) - 1
-
-        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.
-        If it doesn't exist, create one by default.
-        Optionally return None instead.
-        """
-        fnid = self.getfn_id(fn)
-
-        if fnid in self.tasks_lookup:
-            if task in self.tasks_lookup[fnid]:
-                return self.tasks_lookup[fnid][task]
-
-        if not create:
-            return None
-
-        self.tasks_name.append(task)
-        self.tasks_fnid.append(fnid)
-        self.tasks_tdepends.append([])
-        self.tasks_idepends.append([])
-
-        listid = len(self.tasks_name) - 1
-
-        if fnid not in self.tasks_lookup:
-            self.tasks_lookup[fnid] = {}
-        self.tasks_lookup[fnid][task] = listid
-
-        return listid
-
-    def add_tasks(self, fn, dataCache):
-        """
-        Add tasks for a given fn to the database
-        """
-
-        task_deps = dataCache.task_deps[fn]
-
-        fnid = self.getfn_id(fn)
-
-        if fnid in self.failed_fnids:
-            bb.msg.fatal(bb.msg.domain.TaskData, "Trying to re-add a failed file? Something is broken...")
-
-        # Check if we've already seen this fn
-        if fnid in self.tasks_fnid:
-            return
-
-        for task in task_deps['tasks']:
-
-            # Work out task dependencies
-            parentids = []
-            for dep in task_deps['parents'][task]:
-                parentid = self.gettask_id(fn, dep)
-                parentids.append(parentid)
-            taskid = self.gettask_id(fn, task)
-            self.tasks_tdepends[taskid].extend(parentids)
-
-            # Touch all intertask dependencies
-            if 'depends' in task_deps and task in task_deps['depends']:
-                ids = []
-                for dep in task_deps['depends'][task].split():
-                    if dep:
-                        ids.append(((self.getbuild_id(dep.split(":")[0])), dep.split(":")[1]))
-                self.tasks_idepends[taskid].extend(ids)
-
-        # Work out build dependencies
-        if not fnid in self.depids:
-            dependids = {}
-            for depend in dataCache.deps[fn]:
-                bb.msg.debug(2, bb.msg.domain.TaskData, "Added dependency %s for %s" % (depend, fn))
-                dependids[self.getbuild_id(depend)] = None
-            self.depids[fnid] = dependids.keys()
-
-        # Work out runtime dependencies
-        if not fnid in self.rdepids:
-            rdependids = {}
-            rdepends = dataCache.rundeps[fn]
-            rrecs = dataCache.runrecs[fn]
-            for package in rdepends:
-                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 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()
-
-        for dep in self.depids[fnid]:
-            if dep in self.failed_deps:
-                self.fail_fnid(fnid)
-                return
-        for dep in self.rdepids[fnid]:
-            if dep in self.failed_rdeps:
-                self.fail_fnid(fnid)
-                return
-
-    def have_build_target(self, target):
-        """
-        Have we a build target matching this name?
-        """
-        targetid = self.getbuild_id(target)
-
-        if targetid in self.build_targets:
-            return True
-        return False
-
-    def have_runtime_target(self, target):
-        """
-        Have we a runtime target matching this name?
-        """
-        targetid = self.getrun_id(target)
-
-        if targetid in self.run_targets:
-            return True
-        return False
-
-    def add_build_target(self, fn, item):
-        """
-        Add a build target.
-        If already present, append the provider fn to the list
-        """
-        targetid = self.getbuild_id(item)
-        fnid = self.getfn_id(fn)
-
-        if targetid in self.build_targets:
-            if fnid in self.build_targets[targetid]:
-                return
-            self.build_targets[targetid].append(fnid)
-            return
-        self.build_targets[targetid] = [fnid]
-
-    def add_runtime_target(self, fn, item):
-        """
-        Add a runtime target.
-        If already present, append the provider fn to the list
-        """
-        targetid = self.getrun_id(item)
-        fnid = self.getfn_id(fn)
-
-        if targetid in self.run_targets:
-            if fnid in self.run_targets[targetid]:
-                return
-            self.run_targets[targetid].append(fnid)
-            return
-        self.run_targets[targetid] = [fnid]
-
-    def mark_external_target(self, item):
-        """
-        Mark a build target as being externally requested
-        """
-        targetid = self.getbuild_id(item)
-
-        if targetid not in self.external_targets:
-            self.external_targets.append(targetid)
-
-    def get_unresolved_build_targets(self, dataCache):
-        """
-        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:
-                continue
-            if self.build_names_index.index(target) in self.failed_deps:
-                continue
-            if not self.have_build_target(target):
-                unresolved.append(target)
-        return unresolved
-
-    def get_unresolved_run_targets(self, dataCache):
-        """
-        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:
-                continue
-            if self.run_names_index.index(target) in self.failed_rdeps:
-                continue
-            if not self.have_runtime_target(target):
-                unresolved.append(target)
-        return unresolved
-
-    def get_provider(self, item):
-        """
-        Return a list of providers of item
-        """
-        targetid = self.getbuild_id(item)
-   
-        return self.build_targets[targetid]
-
-    def get_dependees(self, itemid):
-        """
-        Return a list of targets which depend on item
-        """
-        dependees = []
-        for fnid in self.depids:
-            if itemid in self.depids[fnid]:
-                dependees.append(fnid)
-        return dependees
-
-    def get_dependees_str(self, item):
-        """
-        Return a list of targets which depend on item as a user readable string
-        """
-        itemid = self.getbuild_id(item)
-        dependees = []
-        for fnid in self.depids:
-            if itemid in self.depids[fnid]:
-                dependees.append(self.fn_index[fnid])
-        return dependees
-
-    def get_rdependees(self, itemid):
-        """
-        Return a list of targets which depend on runtime item
-        """
-        dependees = []
-        for fnid in self.rdepids:
-            if itemid in self.rdepids[fnid]:
-                dependees.append(fnid)
-        return dependees
-
-    def get_rdependees_str(self, item):
-        """
-        Return a list of targets which depend on runtime item as a user readable string
-        """
-        itemid = self.getrun_id(item)
-        dependees = []
-        for fnid in self.rdepids:
-            if itemid in self.rdepids[fnid]:
-                dependees.append(self.fn_index[fnid])
-        return dependees
-
-    def add_provider(self, cfgData, dataCache, item):
-        try:
-            self.add_provider_internal(cfgData, dataCache, item)
-        except bb.providers.NoProvider:
-            if self.abort:
-                if self.get_rdependees_str(item):
-                    bb.msg.error(bb.msg.domain.Provider, "Nothing PROVIDES '%s' (but '%s' DEPENDS on or otherwise requires it)" % (item, self.get_dependees_str(item)))
-                else:
-                    bb.msg.error(bb.msg.domain.Provider, "Nothing PROVIDES '%s'" % (item))
-                raise
-            targetid = self.getbuild_id(item)
-            self.remove_buildtarget(targetid)
-
-        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 
-        added internally during dependency resolution
-        """
-
-        if item in dataCache.ignored_dependencies:
-            return
-
-        if not item in dataCache.providers:
-            if self.get_rdependees_str(item):
-                bb.msg.note(2, bb.msg.domain.Provider, "Nothing PROVIDES '%s' (but '%s' DEPENDS on or otherwise requires it)" % (item, self.get_dependees_str(item)))
-            else:
-                bb.msg.note(2, bb.msg.domain.Provider, "Nothing PROVIDES '%s'" % (item))
-            bb.event.fire(bb.event.NoProvider(item, cfgData))
-            raise bb.providers.NoProvider(item)
-
-        if self.have_build_target(item):
-            return
-
-        all_p = dataCache.providers[item]
-
-        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 buildable provider PROVIDES '%s' but '%s' DEPENDS on or otherwise requires it. Enable debugging and see earlier logs to find unbuildable providers." % (item, self.get_dependees_str(item)))
-            bb.event.fire(bb.event.NoProvider(item, cfgData))
-            raise bb.providers.NoProvider(item)
-
-        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))
-            self.consider_msgs_cache.append(item)
-
-        for fn in eligible:
-            fnid = self.getfn_id(fn)
-            if fnid in self.failed_fnids:
-                continue
-            bb.msg.debug(2, bb.msg.domain.Provider, "adding %s to satisfy %s" % (fn, item))
-            self.add_build_target(fn, item)
-            self.add_tasks(fn, dataCache)
-
-
-            #item = dataCache.pkg_fn[fn]
-
-    def add_rprovider(self, cfgData, dataCache, item):
-        """
-        Add the runtime providers of item to the task data
-        (takes item names from RDEPENDS/PACKAGES namespace)
-        """
-
-        if item in dataCache.ignored_dependencies:
-            return
-
-        if self.have_runtime_target(item):
-            return
-
-        all_p = bb.providers.getRuntimeProviders(dataCache, item)
-
-        if not all_p:
-            bb.msg.error(bb.msg.domain.Provider, "'%s' RDEPENDS/RRECOMMENDS or otherwise requires the runtime entity '%s' but it wasn't found in any PACKAGE or RPROVIDES variables" % (self.get_rdependees_str(item), item))
-            bb.event.fire(bb.event.NoProvider(item, cfgData, runtime=True))
-            raise bb.providers.NoRProvider(item)
-
-        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, "'%s' RDEPENDS/RRECOMMENDS or otherwise requires the runtime entity '%s' but it wasn't found in any PACKAGE or RPROVIDES variables of any buildable targets.\nEnable debugging and see earlier logs to find unbuildable targets." % (self.get_rdependees_str(item), item))
-            bb.event.fire(bb.event.NoProvider(item, cfgData, runtime=True))
-            raise bb.providers.NoRProvider(item)
-
-        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))
-            self.consider_msgs_cache.append(item)
-
-        if numberPreferred > 1:
-            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 (top %s entries preferred) (%s);" % (item, numberPreferred, ", ".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))
-            self.consider_msgs_cache.append(item)
-
-        # run through the list until we find one that we can build
-        for fn in eligible:
-            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))
-            self.add_runtime_target(fn, item)
-            self.add_tasks(fn, dataCache)
-
-    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, "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, 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, missing_list)
-
-    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
-        """
-        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, 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)
-
-        if self.abort and targetid in self.external_targets:
-            bb.msg.error(bb.msg.domain.Provider, "Required build target '%s' has no buildable providers.\nMissing or unbuildable dependency chain was: %s" % (self.build_names_index[targetid], missing_list))
-            raise bb.providers.NoProvider
-
-    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
-        """
-        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, missing_list)
-
-    def add_unresolved(self, cfgData, dataCache):
-        """
-        Resolve all unresolved build and runtime targets
-        """
-        bb.msg.note(1, bb.msg.domain.TaskData, "Resolving any missing task queue dependencies")
-        while 1:
-            added = 0
-            for target in self.get_unresolved_build_targets(dataCache):
-                try:
-                    self.add_provider_internal(cfgData, dataCache, target)
-                    added = added + 1
-                except bb.providers.NoProvider:
-                    targetid = self.getbuild_id(target)
-                    if self.abort and targetid in self.external_targets:
-                        if self.get_rdependees_str(target):
-                            bb.msg.error(bb.msg.domain.Provider, "Nothing PROVIDES '%s' (but '%s' DEPENDS on or otherwise requires it)" % (target, self.get_dependees_str(target)))
-                        else:
-                            bb.msg.error(bb.msg.domain.Provider, "Nothing PROVIDES '%s'" % (target))
-                        raise
-                    self.remove_buildtarget(targetid)
-            for target in self.get_unresolved_run_targets(dataCache):
-                try:
-                    self.add_rprovider(cfgData, dataCache, target)
-                    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")
-            if added == 0:
-                break
-        # self.dump_data()
-
-    def dump_data(self):
-        """
-        Dump some debug information on the internal data structures
-        """
-        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 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 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], 
-                self.tasks_tdepends[task]))
-
-        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-dev/lib/bb/ui/init.py
+++ b/bitbake-dev/lib/bb/ui/init.py
@@ -1,18 +0,0 @@
-#
-# 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-dev/lib/bb/ui/crumbs/init.py
+++ b/bitbake-dev/lib/bb/ui/crumbs/init.py
@@ -1,18 +0,0 @@
-#
-# 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-dev/lib/bb/ui/crumbs/runningbuild.py
+++ b/bitbake-dev/lib/bb/ui/crumbs/runningbuild.py
@@ -1,180 +0,0 @@
-#
-# 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 event[1].has_key ('pid'):
-            pid = event[1]['pid']
-            if self.pids_to_task.has_key(pid):
-                (package, task) = self.pids_to_task[pid]
-                parent = self.tasks_to_iter[(package, task)]
-
-        if event[0].startswith('bb.msg.Msg'):
-            # Set a pretty icon for the message based on it's type.
-            if (event[0].startswith ('bb.msg.MsgWarn')):
-                icon = "dialog-warning"
-            elif (event[0].startswith ('bb.msg.MsgErr')):
-                icon = "dialog-error"
-            else:
-                icon = None
-
-            # Ignore the "Running task i of n .." messages
-            if (event[1]['_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[0].split()[-1], # e.g. MsgWarn, MsgError
-                                package, 
-                                task,
-                                event[1]['_message'],
-                                icon, 
-                                False))
-        elif event[0].startswith('bb.build.TaskStarted'):
-            (package, task) = (event[1]['_package'], event[1]['_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 (self.tasks_to_iter.has_key ((package, None))):
-                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 event[0].startswith('bb.build.Task'):
-
-            if event[0].startswith('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 event[0].startswith('bb.event.BuildCompleted'):
-            failures = int (event[1]['_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-dev/lib/bb/ui/depexp.py
+++ b/bitbake-dev/lib/bb/ui/depexp.py
@@ -1,272 +0,0 @@
-#
-# 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, 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 event[0].startswith('bb.event.ParseProgress'):
-                x = event[1]['sofar']
-                y = event[1]['total']
-                if x == y:
-                    print("\nParsing finished. %d cached, %d parsed, %d skipped, %d masked, %d errors." 
-                        % ( event[1]['cached'], event[1]['parsed'], event[1]['skipped'], event[1]['masked'], event[1]['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 event[0] == "bb.event.DepTreeGenerated":
-                gtk.gdk.threads_enter()
-                parse(event[1]['_depgraph'], dep.pkg_model, dep.depends_model)
-                gtk.gdk.threads_leave()
-
-            if event[0] == 'bb.command.CookerCommandCompleted':
-                continue
-            if event[0] == 'bb.command.CookerCommandFailed':
-                print "Command execution failed: %s" % event[1]['error']
-                break
-            if event[0] == '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-dev/lib/bb/ui/goggle.py
+++ b/bitbake-dev/lib/bb/ui/goggle.py
@@ -1,77 +0,0 @@
-#
-# 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, 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-dev/lib/bb/ui/knotty.py
+++ b/bitbake-dev/lib/bb/ui/knotty.py
@@ -1,162 +0,0 @@
-#
-# 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.
-
-import os
-
-import sys
-import itertools
-import xmlrpclib
-
-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"])
-
-    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, 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
-            if event[0].startswith('bb.msg.MsgPlain'):
-                print event[1]['_message']
-                continue
-            if event[0].startswith('bb.msg.MsgDebug'):
-                print 'DEBUG: ' + event[1]['_message']
-                continue
-            if event[0].startswith('bb.msg.MsgNote'):
-                print 'NOTE: ' + event[1]['_message']
-                continue
-            if event[0].startswith('bb.msg.MsgWarn'):
-                print 'WARNING: ' + event[1]['_message']
-                continue
-            if event[0].startswith('bb.msg.MsgError'):
-                return_value = 1
-                print 'ERROR: ' + event[1]['_message']
-                continue
-            if event[0].startswith('bb.msg.MsgFatal'):
-                return_value = 1
-                print 'FATAL: ' + event[1]['_message']
-                break
-            if event[0].startswith('bb.build.TaskFailed'):
-                return_value = 1
-                logfile = event[1]['logfile']
-                if 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 event[0].startswith('bb.build.Task'):
-                print "NOTE: %s" % event[1]['_message']
-                continue
-            if event[0].startswith('bb.event.ParseProgress'):
-                x = event[1]['sofar']
-                y = event[1]['total']
-                if os.isatty(sys.stdout.fileno()):
-                    sys.stdout.write("\rNOTE: Handling BitBake files: %s (%04d/%04d) [%2d %%]" % ( parsespin.next(), 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 finished. %d cached, %d parsed, %d skipped, %d masked, %d errors." 
-                        % ( event[1]['cached'], event[1]['parsed'], event[1]['skipped'], event[1]['masked'], event[1]['errors']))
-                continue
-
-            if event[0] == 'bb.command.CookerCommandCompleted':
-                break
-            if event[0] == 'bb.command.CookerCommandSetExitCode':
-                return_value = event[1]['exitcode']
-                continue
-            if event[0] == 'bb.command.CookerCommandFailed':
-                return_value = 1
-                print "Command execution failed: %s" % event[1]['error']
-                break
-            if event[0] == 'bb.cooker.CookerExit':
-                break
-
-            # ignore
-            if event[0].startswith('bb.event.BuildStarted'):
-                continue
-            if event[0].startswith('bb.event.BuildCompleted'):
-                continue
-            if event[0].startswith('bb.event.MultipleProviders'):
-                continue
-            if event[0].startswith('bb.runqueue.runQueue'):
-                continue
-            if event[0].startswith('bb.event.StampUpdate'):
-                continue
-            if event[0].startswith('bb.event.ConfigParsed'):
-                continue
-            if event[0].startswith('bb.event.RecipeParsed'):
-                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-dev/lib/bb/ui/uihelper.py
+++ b/bitbake-dev/lib/bb/ui/uihelper.py
@@ -1,49 +0,0 @@
-# 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 event[0].startswith('bb.build.TaskStarted'):
-            self.running_tasks["%s %s\n" % (event[1]['_package'], event[1]['_task'])] = ""
-            self.needUpdate = True
-        if event[0].startswith('bb.build.TaskSucceeded'):
-            del self.running_tasks["%s %s\n" % (event[1]['_package'], event[1]['_task'])]
-            self.needUpdate = True
-        if event[0].startswith('bb.build.TaskFailed'):
-            del self.running_tasks["%s %s\n" % (event[1]['_package'], event[1]['_task'])]
-            self.failed_tasks["%s %s\n" % (event[1]['_package'], event[1]['_task'])] = ""
-            self.needUpdate = True
-
-        # Add runqueue event handling
-        #if event[0].startswith('bb.runqueue.runQueueTaskCompleted'):
-        #    a = 1
-        #if event[0].startswith('bb.runqueue.runQueueTaskStarted'):
-        #    a = 1
-        #if event[0].startswith('bb.runqueue.runQueueTaskFailed'):
-        #    a = 1
-        #if event[0].startswith('bb.runqueue.runQueueExitWait'):
-        #    a = 1
-
-    def getTasks(self):
-        return (self.running_tasks, self.failed_tasks)
--- a/bitbake-dev/lib/bb/utils.py
+++ b/bitbake-dev/lib/bb/utils.py
@@ -1,417 +0,0 @@
-# ex:ts=4:sw=4:sts=4:et
-# -*- tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*-
-"""
-BitBake Utility Functions
-"""
-
-# Copyright (C) 2004 Michael Lauer
-#
-# 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.
-
-digits = "0123456789"
-ascii_letters = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
-
-import re, fcntl, os
-
-def explode_version(s):
-    r = []
-    alpha_regexp = re.compile('^([a-zA-Z]+)(.*)$')
-    numeric_regexp = re.compile('^(\d+)(.*)$')
-    while (s != ''):
-        if s[0] in digits:
-            m = numeric_regexp.match(s)
-            r.append(int(m.group(1)))
-            s = m.group(2)
-            continue
-        if s[0] in ascii_letters:
-            m = alpha_regexp.match(s)
-            r.append(m.group(1))
-            s = m.group(2)
-            continue
-        s = s[1:]
-    return r
-
-def vercmp_part(a, b):
-    va = explode_version(a)
-    vb = explode_version(b)
-    while True:
-        if va == []:
-            ca = None
-        else:
-            ca = va.pop(0)
-        if vb == []:
-            cb = None
-        else:
-            cb = vb.pop(0)
-        if ca == None and cb == None:
-            return 0
-        if ca > cb:
-            return 1
-        if ca < cb:
-            return -1
-
-def vercmp(ta, tb):
-    (ea, va, ra) = ta
-    (eb, vb, rb) = tb
-
-    r = int(ea)-int(eb)
-    if (r == 0):
-        r = vercmp_part(va, vb)
-    if (r == 0):
-        r = vercmp_part(ra, rb)
-    return r
-
-def explode_deps(s):
-    """
-    Take an RDEPENDS style string of format:
-    "DEPEND1 (optional version) DEPEND2 (optional version) ..."
-    and return a list of dependencies.
-    Version information is ignored.
-    """
-    r = []
-    l = s.split()
-    flag = False
-    for i in l:
-        if i[0] == '(':
-            flag = True
-            #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 dictonary of dependencies and versions.
-    """
-    r = {}
-    l = s.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 _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):
-        bb.msg.error(bb.msg.domain.Util, "\t%.4d:%s" % (i, body[i-1]) )
-
-
-def better_compile(text, file, realfile):
-    """
-    A better compile method. This method
-    will print  the offending lines.
-    """
-    try:
-        return compile(text, file, "exec")
-    except Exception, e:
-        import bb,sys
-
-        # split the text into lines again
-        body = text.split('\n')
-        bb.msg.error(bb.msg.domain.Util, "Error in compiling python function in: ", 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)
-
-def better_exec(code, context, text, realfile):
-    """
-    Similiar to better_compile, better_exec will
-    print the lines that are responsible for the
-    error.
-    """
-    import bb,sys
-    try:
-        exec code in context
-    except:
-        (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 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
-
-        import traceback
-        line = traceback.tb_lineno(tb)
-
-        _print_trace( text.split('\n'), line )
-        
-        raise
-
-def Enum(*names):
-   """
-   A simple class to give Enum support
-   """
-
-   assert names, "Empty enums are not supported"
-
-   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)
-
-   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])
-
-   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
-
-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):
-        import bb, sys
-        bb.msg.error(bb.msg.domain.Util, "Error, lockfile path does not exist!: %s" % path)
-        sys.exit(1)
-
-    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.
-
-        # 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, 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',
-        '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.
-    """
-
-    import bb
-
-    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.debug(1, "Removed the following variables from the environment:", ",".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 variable 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
-    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)
-
-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
--- a/bitbake-dev/lib/bb/xmlrpcserver.py
+++ b/bitbake-dev/lib/bb/xmlrpcserver.py
@@ -1,145 +0,0 @@
-#
-# 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
-
-DEBUG = False
-
-from SimpleXMLRPCServer import SimpleXMLRPCServer, SimpleXMLRPCRequestHandler
-import inspect, select
-
-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 BitBakeXMLRPCServer(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 callable(function)
-        self._idlefuns[function] = data
-
-    def serve_forever(self):
-        """
-        Serve Requests. Overloaded to honor a quit command
-        """
-        self.quit = False
-        while not self.quit:
-            #print "Idle queue length %s" % len(self._idlefuns)
-            if len(self._idlefuns) == 0:
-                self.timeout = None
-            else:
-                self.timeout = 0
-            self.handle_request()
-            #print "Idle timeout, running idle functions"
-            for function, data in self._idlefuns.items():
-                try:
-                    retval = function(self, data, False)
-                    if not retval:
-                        del self._idlefuns[function]
-                except SystemExit:
-                    raise
-                except:
-                    import traceback
-                    traceback.print_exc()
-                    pass
-
-        # 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
--- a/bitbake/AUTHORS
+++ b/bitbake/AUTHORS
@@ -1,8 +1,8 @@
 Tim Ansell <mithro@mithis.net>
 Phil Blundell <pb@handhelds.org>
 Seb Frankengul <seb@frankengul.org>
-Holger Freyther <zecke@handhelds.org>
-Marcin Juszkiewicz <marcin@haerwu.biz>
+Holger Freyther <holger@moiji-mobile.com>
+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,8 +1,99 @@
-Changes in BitBake 1.8.x:
-	- Add bb.utils.prune_suffix function
- 
-Changes in BitBake 1.8.12:
-	- Fix -f (force) in conjunction with -b
+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)
+	- Promote certain warnings from debug to note 2 level
+	- Update manual
+	- 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
@@ -27,8 +118,10 @@ Changes in BitBake 1.8.12:
 	  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
@@ -44,9 +137,8 @@ Changes in BitBake 1.8.12:
 	- Add PERSISTENT_DIR to store the PersistData in a persistent
 	  directory != the cache dir.
 	- Add md5 and sha256 checksum generation functions to utils.py
-	- Make sure Build Completed events are generated even when tasks fail
 	- Correctly handle '-' characters in class names (#2958)
-	- Make sure expandKeys has been called on the data dictonary before running tasks
+	- 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)
@@ -63,6 +155,7 @@ Changes in BitBake 1.8.12:
 	  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
@@ -76,109 +169,15 @@ Changes in BitBake 1.8.12:
 	  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)
-
-Changes in BitBake 1.8.10:
-	- Psyco is available only for x86 - do not use it on other architectures.
-	- 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)
-	- 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)
-	- Fix bogus preferred_version return values
-	- 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 git branch support
-	- 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
-	- bb.utils.prunedir can cope with symlinks to directories without exceptions
-
-Changes in Bitbake 1.8.8:
-	- 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)
-	- Import persistent data store from trunk
-	- Sync fetcher code with that in trunk, adding SRCREV support for svn
-	- Add ConfigParsed Event after configuration parsing is complete
-	- 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
-	- Add plain message function to bb.msg
-	- Sort the list of providers before processing so dependency problems are 
-	  reproducible rather than effectively random
-	- 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
-	- Fix handling of variables with expansion in the name using _append/_prepend
-	  e.g. RRECOMMENDS_${PN}_append_xyz = "abc"
-	- 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
-
-Changes in Bitbake 1.8.6:
-	- Correctly redirect stdin when forking
-	- If parsing errors are found, exit, too many users miss the errors
-	- Remove supriours PREFERRED_PROVIDER warnings
-
-Changes in Bitbake 1.8.4:
-	- 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
+	- 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,53 +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/bzr.py
-lib/bb/fetch/cvs.py
-lib/bb/fetch/git.py
-lib/bb/fetch/hg.py
-lib/bb/fetch/local.py
-lib/bb/fetch/osc.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/persist_data.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/bitbake
+++ b/bitbake/bin/bitbake
@@ -22,125 +22,223 @@
 # 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
+import os
+import sys, logging
+sys.path.insert(0, os.path.join(os.path.dirname(os.path.dirname(__file__)),
+                                'lib'))
+
+import optparse
+import warnings
+from traceback import format_exception
+try:
+    import bb
+except RuntimeError as exc:
+    sys.exit(str(exc))
+from bb import event
+import bb.msg
 from bb import cooker
+from bb import ui
+from bb import server

-__version__ = "1.8.13"
+__version__ = "1.13.3"
+logger = logging.getLogger("BitBake")

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


-#============================================================================#
-# main
-#============================================================================#
+def get_ui(config):
+    if config.ui:
+        interface = config.ui
+    else:
+        interface = '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.
+        module = __import__("bb.ui", fromlist = [interface])
+        return getattr(module, interface).main
+    except AttributeError:
+        sys.exit("FATAL: Invalid user interface '%s' specified.\n"
+                 "Valid interfaces: depexp, goggle, ncurses, knotty [default]." % interface)
+
+
+# Display bitbake/OE warnings via the BitBake.Warnings logger, ignoring others"""
+warnlog = logging.getLogger("BitBake.Warnings")
+_warnings_showwarning = warnings.showwarning
+def _showwarning(message, category, filename, lineno, file=None, line=None):
+    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)
+        warnlog.warn(s)
+
+warnings.showwarning = _showwarning
+warnings.filterwarnings("ignore")
+warnings.filterwarnings("default", module="(<string>$|(oe|bb)\.)")
+warnings.filterwarnings("ignore", category=PendingDeprecationWarning)
+warnings.filterwarnings("ignore", category=ImportWarning)
+warnings.filterwarnings("ignore", category=DeprecationWarning, module="<string>$")
+warnings.filterwarnings("ignore", message="With-statements now directly support multiple context managers")
+

 def main():
-    parser = optparse.OptionParser( version = "BitBake Build Tool Core version %s, %%prog version %s" % ( bb.__version__, __version__ ),
-    usage = """%prog [options] [package ...]
+    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 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. Does not handle any dependencies.",
+               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( "-a", "--tryaltconfigs", help = "continue with builds by trying to use alternative providers where possible.",
-               action = "store_true", dest = "tryaltconfigs", 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( "-f", "--force", help = "force run of specified cmd, regardless of stamp status",
-               action = "store_true", dest = "force", 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( "-i", "--interactive", help = "drop into the interactive mode also called the BitBake shell.",
-               action = "store_true", dest = "interactive", 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 = "prefile", default = [])

-    parser.add_option( "-r", "--read", help = "read the specified file before bitbake.conf",
-               action = "append", dest = "file", default = [] )
+    parser.add_option("-R", "--postread", help = "read the specified file after bitbake.conf",
+                      action = "append", dest = "postfile", 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("-s", "--show-versions", help = "show current and preferred versions of all packages",
+               action = "store_true", dest = "show_versions", 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("-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( "-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("-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( "-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("-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("-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("-P", "--profile", help = "profile the command and print a report",
+               action = "store_true", dest = "profile", default = False)

-    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 )
+    parser.add_option("-u", "--ui", help = "userinterface to use",
+               action = "store", dest = "ui")
+
+    parser.add_option("-t", "--servertype", help = "Choose which server to use, none, process or xmlrpc",
+               action = "store", dest = "servertype")
+
+    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:])

-    cooker = bb.cooker.BBCooker(configuration)
+    ui_main = get_ui(configuration)

+    # Server type can be xmlrpc, process or none currently, if nothing is specified,
+    # the default server is process
+    if configuration.servertype:
+        server_type = configuration.servertype
+    else:
+        server_type = 'process'
+
+    try:
+        module = __import__("bb.server", fromlist = [server_type])
+        server = getattr(module, server_type)
+    except AttributeError:
+        sys.exit("FATAL: Invalid server type '%s' specified.\n"
+                 "Valid interfaces: xmlrpc, process [default], none." % servertype)
+
+    # 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.msg.init_msgconfig(configuration.verbose, configuration.debug,
+                         configuration.debug_domains)
+
+    # Ensure logging messages get sent to the UI as events
+    handler = bb.event.LogHandler()
+    logger.addHandler(handler)
+
+    # Before we start modifying the environment we should take a pristine
+    # copy for possible later use
+    initialenv = os.environ.copy()
    # Clear away any spurious environment variables. But don't wipe the
-    # environment totally.
+    # environment totally. This is necessary to ensure the correct operation
+    # of the UIs (e.g. for DISPLAY, etc.)
    bb.utils.clean_environment()

-    cooker.parseConfiguration()
+    server = server.BitBakeServer()

-    if configuration.profile:
-        try:
-            import cProfile as profile
-        except:
-            import profile
+    server.initServer()
+    idle = server.getServerIdleCB()

-        profile.runctx("cooker.cook()", globals(), locals(), "profile.log")
-        import pstats
-        p = pstats.Stats('profile.log')
-        p.sort_stats('time')
-        p.print_stats()
-        p.print_callers()
-        p.sort_stats('cumulative')
-        p.print_stats()
-    else:
-        cooker.cook()
+    cooker = bb.cooker.BBCooker(configuration, idle, initialenv)
+    cooker.parseCommandLine()
+
+    server.addcooker(cooker)
+    server.saveConnectionDetails()
+    server.detach(cooker_logfile)
+
+    # Should no longer need to ever reference cooker
+    del cooker
+
+    logger.removeHandler(handler)
+
+    # Setup a connection to the server (cooker)
+    server_connection = server.establishConnection()
+
+    try:
+        return server.launchUI(ui_main, server_connection.connection, server_connection.events)
+    finally:
+        bb.event.ui_queue = []
+        server_connection.terminate()
+
+    return 1

 if __name__ == "__main__":
-    main()
+    try:
+        ret = main()
+    except Exception:
+        ret = 1
+        import traceback
+        traceback.print_exc(5)
+    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-layers
+++ b/bitbake/bin/bitbake-layers
@@ -0,0 +1,299 @@
+#!/usr/bin/env python
+
+# This script has subcommands which operate against your bitbake layers, either
+# displaying useful information, or acting against them.
+# See the help output for details on available commands.
+
+import cmd
+import logging
+import os
+import sys
+
+bindir = os.path.dirname(__file__)
+topdir = os.path.dirname(bindir)
+sys.path[0:0] = [os.path.join(topdir, 'lib')]
+
+import bb.cache
+import bb.cooker
+import bb.providers
+import bb.utils
+from bb.cooker import state
+
+
+logger = logging.getLogger('BitBake')
+
+
+def main(args):
+    # Set up logging
+    console = logging.StreamHandler(sys.stdout)
+    format = bb.msg.BBLogFormatter("%(levelname)s: %(message)s")
+    bb.msg.addDefaultlogFilter(console)
+    console.setFormatter(format)
+    logger.addHandler(console)
+
+    initialenv = os.environ.copy()
+    bb.utils.clean_environment()
+
+    cmds = Commands(initialenv)
+    if args:
+        cmds.onecmd(' '.join(args))
+    else:
+        cmds.do_help('')
+    return cmds.returncode
+
+
+class Commands(cmd.Cmd):
+    def __init__(self, initialenv):
+        cmd.Cmd.__init__(self)
+        self.returncode = 0
+        self.config = Config(parse_only=True)
+        self.cooker = bb.cooker.BBCooker(self.config,
+                                         self.register_idle_function,
+                                         initialenv)
+        self.config_data = self.cooker.configuration.data
+        bb.providers.logger.setLevel(logging.ERROR)
+        self.cooker_data = None
+
+    def register_idle_function(self, function, data):
+        pass
+
+    def prepare_cooker(self):
+        sys.stderr.write("Parsing recipes..")
+        logger.setLevel(logging.WARNING)
+
+        try:
+            while self.cooker.state in (state.initial, state.parsing):
+                self.cooker.updateCache()
+        except KeyboardInterrupt:
+            self.cooker.shutdown()
+            self.cooker.updateCache()
+            sys.exit(2)
+
+        logger.setLevel(logging.INFO)
+        sys.stderr.write("done.\n")
+
+        self.cooker_data = self.cooker.status
+        self.cooker_data.appends = self.cooker.appendlist
+
+    def check_prepare_cooker(self):
+        if not self.cooker_data:
+            self.prepare_cooker()
+
+    def default(self, line):
+        """Handle unrecognised commands"""
+        sys.stderr.write("Unrecognised command or option\n")
+        self.do_help('')
+
+    def do_help(self, topic):
+        """display general help or help on a specified command"""
+        if topic:
+            sys.stdout.write('%s: ' % topic)
+            cmd.Cmd.do_help(self,topic)
+        else:
+            sys.stdout.write("usage: bitbake-layers <command> [arguments]\n\n")
+            sys.stdout.write("Available commands:\n")
+            procnames = self.get_names()
+            for procname in procnames:
+                if procname[:3] == 'do_':
+                    sys.stdout.write("  %s\n" % procname[3:])
+                    doc = getattr(self, procname).__doc__
+                    if doc:
+                        sys.stdout.write("    %s\n" % doc.splitlines()[0])
+
+    def do_show_layers(self, args):
+        """show current configured layers"""
+        self.check_prepare_cooker()
+        logger.plain('')
+        logger.plain("%s  %s  %s" % ("layer".ljust(20), "path".ljust(40), "priority"))
+        logger.plain('=' * 74)
+        layerdirs = str(self.config_data.getVar('BBLAYERS', True)).split()
+        for layerdir in layerdirs:
+            layername = '?'
+            layerpri = 0
+            for layer, _, regex, pri in self.cooker.status.bbfile_config_priorities:
+                if regex.match(os.path.join(layerdir, 'test')):
+                    layername = layer
+                    layerpri = pri
+                    break
+
+            logger.plain("%s  %s  %d" % (layername.ljust(20), layerdir.ljust(40), layerpri))
+
+    def do_show_overlayed(self, args):
+        """list overlayed recipes (where there is a recipe in another layer that has a higher layer priority)
+
+usage: show_overlayed
+
+Highest priority recipes are listed with the recipes they overlay as subitems.
+"""
+        self.check_prepare_cooker()
+        if self.cooker.overlayed:
+            logger.plain('Overlayed recipes:')
+            for f in self.cooker.overlayed.iterkeys():
+                logger.plain('%s' % f)
+                for of in self.cooker.overlayed[f]:
+                    logger.plain('  %s' % of)
+        else:
+            logger.plain('No overlayed recipes found')
+
+    def do_flatten(self, args):
+        """flattens layer configuration into a separate output directory.
+
+usage: flatten <outputdir>
+
+Takes the current layer configuration and builds a "flattened" directory
+containing the contents of all layers, with any overlayed recipes removed
+and bbappends appended to the corresponding recipes. Note that some manual
+cleanup may still be necessary afterwards, in particular:
+
+* where non-recipe files (such as patches) are overwritten (the flatten
+  command will show a warning for these)
+* where anything beyond the normal layer setup has been added to
+  layer.conf (only the lowest priority layer's layer.conf is used)
+* overridden/appended items from bbappends will need to be tidied up
+"""
+        arglist = args.split()
+        if len(arglist) != 1:
+            logger.error('Please specify an output directory')
+            self.do_help('flatten')
+            return
+
+        if os.path.exists(arglist[0]) and os.listdir(arglist[0]):
+            logger.error('Directory %s exists and is non-empty, please clear it out first' % arglist[0])
+            return
+
+        self.check_prepare_cooker()
+        layers = (self.config_data.getVar('BBLAYERS', True) or "").split()
+        for layer in layers:
+            overlayed = []
+            for f in self.cooker.overlayed.iterkeys():
+                for of in self.cooker.overlayed[f]:
+                    if of.startswith(layer):
+                        overlayed.append(of)
+
+            logger.plain('Copying files from %s...' % layer )
+            for root, dirs, files in os.walk(layer):
+                for f1 in files:
+                    f1full = os.sep.join([root, f1])
+                    if f1full in overlayed:
+                        logger.plain('  Skipping overlayed file %s' % f1full )
+                    else:
+                        ext = os.path.splitext(f1)[1]
+                        if ext != '.bbappend':
+                            fdest = f1full[len(layer):]
+                            fdest = os.path.normpath(os.sep.join([arglist[0],fdest]))
+                            bb.utils.mkdirhier(os.path.dirname(fdest))
+                            if os.path.exists(fdest):
+                                if f1 == 'layer.conf' and root.endswith('/conf'):
+                                    logger.plain('  Skipping layer config file %s' % f1full )
+                                    continue
+                                else:
+                                    logger.warn('Overwriting file %s', fdest)
+                            bb.utils.copyfile(f1full, fdest)
+                            if ext == '.bb':
+                                if f1 in self.cooker_data.appends:
+                                    appends = self.cooker_data.appends[f1]
+                                    if appends:
+                                        logger.plain('  Applying appends to %s' % fdest )
+                                        for appendname in appends:
+                                            self.apply_append(appendname, fdest)
+
+    def get_append_layer(self, appendname):
+        for layer, _, regex, _ in self.cooker.status.bbfile_config_priorities:
+            if regex.match(appendname):
+                return layer
+        return "?"
+
+    def apply_append(self, appendname, recipename):
+        appendfile = open(appendname, 'r')
+        recipefile = open(recipename, 'a')
+        recipefile.write('\n')
+        recipefile.write('##### bbappended from %s #####\n' % self.get_append_layer(appendname))
+        recipefile.writelines(appendfile.readlines())
+
+    def do_show_appends(self, args):
+        """list bbappend files and recipe files they apply to
+
+usage: show_appends
+
+Recipes are listed with the bbappends that apply to them as subitems.
+"""
+        self.check_prepare_cooker()
+        if not self.cooker_data.appends:
+            logger.plain('No append files found')
+            return
+
+        logger.plain('State of append files:')
+
+        pnlist = list(self.cooker_data.pkg_pn.keys())
+        pnlist.sort()
+        for pn in pnlist:
+            self.show_appends_for_pn(pn)
+
+        self.show_appends_for_skipped()
+
+    def show_appends_for_pn(self, pn):
+        filenames = self.cooker_data.pkg_pn[pn]
+
+        best = bb.providers.findBestProvider(pn,
+                                             self.cooker.configuration.data,
+                                             self.cooker_data,
+                                             self.cooker_data.pkg_pn)
+        best_filename = os.path.basename(best[3])
+
+        self.show_appends_output(filenames, best_filename)
+
+    def show_appends_for_skipped(self):
+        filenames = [os.path.basename(f)
+                    for f in self.cooker.skiplist.iterkeys()]
+        self.show_appends_output(filenames, None, " (skipped)")
+
+    def show_appends_output(self, filenames, best_filename, name_suffix = ''):
+        appended, missing = self.get_appends_for_files(filenames)
+        if appended:
+            for basename, appends in appended:
+                logger.plain('%s%s:', basename, name_suffix)
+                for append in appends:
+                    logger.plain('  %s', append)
+
+            if best_filename:
+                if best_filename in missing:
+                    logger.warn('%s: missing append for preferred version',
+                                best_filename)
+                    self.returncode |= 1
+
+
+    def get_appends_for_files(self, filenames):
+        appended, notappended = [], []
+        for filename in filenames:
+            _, cls = bb.cache.Cache.virtualfn2realfn(filename)
+            if cls:
+                continue
+
+            basename = os.path.basename(filename)
+            appends = self.cooker_data.appends.get(basename)
+            if appends:
+                appended.append((basename, list(appends)))
+            else:
+                notappended.append(basename)
+        return appended, notappended
+
+
+class Config(object):
+    def __init__(self, **options):
+        self.pkgs_to_build = []
+        self.debug_domains = []
+        self.extra_assume_provided = []
+        self.prefile = []
+        self.postfile = []
+        self.debug = 0
+        self.__dict__.update(options)
+
+    def __getattr__(self, attribute):
+        try:
+            return super(Config, self).__getattribute__(attribute)
+        except AttributeError:
+            return None
+
+
+if __name__ == '__main__':
+    sys.exit(main(sys.argv[1:]) or 0)
--- a/bitbake/bin/bitbake-prserv
+++ b/bitbake/bin/bitbake-prserv
@@ -0,0 +1,53 @@
+#!/usr/bin/env python
+import os
+import sys,logging
+import optparse
+
+sys.path.insert(0, os.path.join(os.path.dirname(os.path.dirname(__file__)),'lib'))
+
+import prserv
+import prserv.serv
+
+__version__="1.0.0"
+
+PRHOST_DEFAULT=''
+PRPORT_DEFAULT=8585
+
+def main():
+    parser = optparse.OptionParser(
+        version="Bitbake PR Service Core version %s, %%prog version %s" % (prserv.__version__, __version__),
+        usage = "%prog [options]")
+
+    parser.add_option("-f", "--file", help="database filename(default prserv.db)", action="store",
+                      dest="dbfile", type="string", default="prserv.db")
+    parser.add_option("-l", "--log", help="log filename(default prserv.log)", action="store",
+                      dest="logfile", type="string", default="prserv.log")
+    parser.add_option("--loglevel", help="logging level, i.e. CRITICAL, ERROR, WARNING, INFO, DEBUG",
+                      action = "store", type="string", dest="loglevel", default = "WARNING")
+    parser.add_option("--start", help="start daemon",
+                      action="store_true", dest="start", default="True")
+    parser.add_option("--stop", help="stop daemon",
+                      action="store_false", dest="start")
+    parser.add_option("--host", help="ip address to bind", action="store",
+                      dest="host", type="string", default=PRHOST_DEFAULT)
+    parser.add_option("--port", help="port number(default 8585)", action="store",
+                      dest="port", type="int", default=PRPORT_DEFAULT)
+
+    options, args = parser.parse_args(sys.argv)
+
+    prserv.init_logger(os.path.abspath(options.logfile),options.loglevel)
+
+    if options.start:
+        prserv.serv.start_daemon(options)
+    else:
+        prserv.serv.stop_daemon()
+
+if __name__ == "__main__":
+    try:
+        ret = main()
+    except Exception:
+        ret = 1
+        import traceback
+        traceback.print_exc(5)
+    sys.exit(ret)
+
--- a/bitbake/bin/bitbake-runtask
+++ b/bitbake/bin/bitbake-runtask
@@ -0,0 +1,119 @@
+#!/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'))
+from bb import fetch2
+import logging
+
+logger = logging.getLogger("BitBake")
+
+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, **options):
+        self.data = {}
+        self.file = []
+        self.cmd = None
+        self.dump_signatures = True
+        self.prefile = []
+        self.postfile = []
+        self.parse_only = True
+
+    def __getattr__(self, attribute):
+        try:
+            return super(BBConfiguration, self).__getattribute__(attribute)
+        except AttributeError:
+            return None
+
+_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
+import bb.cooker
+
+buildfile = sys.argv[1]
+taskname = sys.argv[2]
+if len(sys.argv) >= 4:
+    dryrun = sys.argv[3]    
+else:
+    dryrun = False
+if len(sys.argv) >= 5:
+    hashfile = sys.argv[4]
+    p = pickle.Unpickler(file(hashfile, "rb"))
+    hashdata = p.load()
+else:
+    hashdata = None
+
+handler = bb.event.LogHandler()
+logger.addHandler(handler)
+
+#An example to make debug log messages show up
+#bb.msg.init_msgconfig(True, 3, [])
+
+console = logging.StreamHandler(sys.stdout)
+format = bb.msg.BBLogFormatter("%(levelname)s: %(message)s")
+bb.msg.addDefaultlogFilter(console)
+console.setFormatter(format)
+
+def worker_fire(event, d):
+    if isinstance(event, logging.LogRecord):
+        console.handle(event)
+bb.event.worker_fire = worker_fire
+bb.event.worker_pid = os.getpid()
+
+initialenv = os.environ.copy()
+config = BBConfiguration()
+
+def register_idle_function(self, function, data):
+    pass
+
+cooker = bb.cooker.BBCooker(config, register_idle_function, initialenv)
+config_data = cooker.configuration.data
+cooker.status = config_data
+cooker.handleCollections(bb.data.getVar("BBFILE_COLLECTIONS", config_data, 1))
+
+fn, cls = bb.cache.Cache.virtualfn2realfn(buildfile)
+buildfile = cooker.matchFile(fn)
+fn = bb.cache.Cache.realfn2virtual(buildfile, cls)
+
+cooker.buildSetVars()
+
+# Load data into the cache for fn and parse the loaded cache data
+the_data = bb.cache.Cache.loadDataFull(fn, cooker.get_file_appends(fn), cooker.configuration.data)
+
+if taskname.endswith("_setscene"):
+    the_data.setVarFlag(taskname, "quieterrors", "1")
+
+if hashdata:
+    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 dryrun != "True":
+    ret = bb.build.exec_task(fn, taskname, the_data)
+sys.exit(ret)
+
--- a/bitbake/bin/bitdoc
+++ b/bitbake/bin/bitdoc
@@ -20,7 +20,7 @@
 import optparse, os, sys

 # bitbake
-sys.path.append(os.path.join(os.path.dirname(os.path.dirname(sys.argv[0])), 'lib'))
+sys.path.append(os.path.join(os.path.dirname(os.path.dirname(__file__), 'lib'))
 import bb
 import bb.parse
 from   string import split, join
@@ -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,13 +426,12 @@ 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 )
-
-    if options.debug:
-        bb.msg.set_debug_level(options.debug)
+ 
+    bb.msg.init_msgconfig(options.verbose, options.debug)

    return options.config, options.output

@@ -443,7 +440,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 +450,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()
@@ -497,7 +496,7 @@ def main():
        doc.insert_doc_item(doc_ins)

    # let us create the HTML now
-    bb.mkdirhier(output_dir)
+    bb.utils.mkdirhier(output_dir)
    os.chdir(output_dir)

    # Let us create the sites now. We do it in the following order
--- a/bitbake/contrib/vim/ftdetect/bitbake.vim
+++ b/bitbake/contrib/vim/ftdetect/bitbake.vim
@@ -1,4 +1,24 @@
-au BufNewFile,BufRead *.bb       setfiletype bitbake
-au BufNewFile,BufRead *.bbclass  setfiletype bitbake
-au BufNewFile,BufRead *.inc      setfiletype bitbake
-" au BufNewFile,BufRead *.conf     setfiletype bitbake
+" Vim filetype detection file
+" Language:     BitBake
+" Author:       Ricardo Salveti <rsalveti@rsalveti.net>
+" Copyright:    Copyright (C) 2008  Ricardo Salveti <rsalveti@rsalveti.net>
+" Licence:      You may redistribute this under the same terms as Vim itself
+"
+" This sets up the syntax highlighting for BitBake files, like .bb, .bbclass and .inc
+
+if &compatible || version < 600
+    finish
+endif
+
+" .bb and .bbclass
+au BufNewFile,BufRead *.b{b,bclass}	set filetype=bitbake
+
+" .inc
+au BufNewFile,BufRead *.inc 		set filetype=bitbake
+
+" .conf
+au BufNewFile,BufRead *.conf
+    \ if (match(expand("%:p:h"), "conf") > 0) |
+    \     set filetype=bitbake |
+    \ endif
+
--- a/bitbake/contrib/vim/ftplugin/bitbake.vim
+++ b/bitbake/contrib/vim/ftplugin/bitbake.vim
@@ -0,0 +1 @@
+set sts=4 sw=4 et
--- a/bitbake/contrib/vim/plugin/newbb.vim
+++ b/bitbake/contrib/vim/plugin/newbb.vim
@@ -0,0 +1,85 @@
+" Vim plugin file
+" Purpose:	Create a template for new bb files
+" Author:	Ricardo Salveti <rsalveti@gmail.com>
+" Copyright:	Copyright (C) 2008 Ricardo Salveti <rsalveti@gmail.com>
+"
+" This file is licensed under the MIT license, see COPYING.MIT in
+" this source distribution for the terms.
+"
+" Based on the gentoo-syntax package
+"
+" Will try to use git to find the user name and email
+
+if &compatible || v:version < 600
+    finish
+endif
+
+fun! <SID>GetUserName()
+    let l:user_name = system("git-config --get user.name")
+    if v:shell_error
+        return "Unknow User"
+    else
+        return substitute(l:user_name, "\n", "", "")
+endfun
+
+fun! <SID>GetUserEmail()
+    let l:user_email = system("git-config --get user.email")
+    if v:shell_error
+        return "unknow@user.org"
+    else
+        return substitute(l:user_email, "\n", "", "")
+endfun
+
+fun! BBHeader()
+    let l:current_year = strftime("%Y")
+    let l:user_name = <SID>GetUserName()
+    let l:user_email = <SID>GetUserEmail()
+    0 put ='# Copyright (C) ' . l:current_year .
+                \ ' ' . l:user_name . ' <' . l:user_email . '>'
+    put ='# Released under the MIT license (see COPYING.MIT for the terms)'
+    $
+endfun
+
+fun! NewBBTemplate()
+    let l:paste = &paste
+    set nopaste
+    
+    " Get the header
+    call BBHeader()
+
+    " New the bb template
+    put ='DESCRIPTION = \"\"'
+    put ='HOMEPAGE = \"\"'
+    put ='LICENSE = \"\"' 
+    put ='SECTION = \"\"'
+    put ='DEPENDS = \"\"'
+    put ='PR = \"r0\"'
+    put =''
+    put ='SRC_URI = \"\"'
+
+    " Go to the first place to edit
+    0
+    /^DESCRIPTION =/
+    exec "normal 2f\""
+
+    if paste == 1
+        set paste
+    endif
+endfun
+
+if !exists("g:bb_create_on_empty")
+    let g:bb_create_on_empty = 1
+endif
+
+" disable in case of vimdiff
+if v:progname =~ "vimdiff"
+    let g:bb_create_on_empty = 0
+endif
+
+augroup NewBB
+    au BufNewFile *.bb
+                \ if g:bb_create_on_empty |
+                \    call NewBBTemplate() |
+                \ endif
+augroup END
+
--- a/bitbake/contrib/vim/syntax/bitbake.vim
+++ b/bitbake/contrib/vim/syntax/bitbake.vim
@@ -1,120 +1,123 @@
 " Vim syntax file
+" Language:     BitBake bb/bbclasses/inc
+" Author:       Chris Larson <kergoth@handhelds.org>
+"               Ricardo Salveti <rsalveti@rsalveti.net>
+" Copyright:    Copyright (C) 2004  Chris Larson <kergoth@handhelds.org>
+"               Copyright (C) 2008  Ricardo Salveti <rsalveti@rsalveti.net>
 "
-" Copyright (C) 2004  Chris Larson <kergoth@handhelds.org>
 " This file is licensed under the MIT license, see COPYING.MIT in
 " this source distribution for the terms.
 "
-" Language:	BitBake
-" Maintainer:	Chris Larson <kergoth@handhelds.org>
-" Filenames:	*.bb, *.bbclass
+" Syntax highlighting for bb, bbclasses and inc files.
+"
+" It's an entirely new type, just has specific syntax in shell and python code

-if version < 600
-  syntax clear
-elseif exists("b:current_syntax")
-  finish
+if &compatible || v:version < 600
+    finish
+endif
+if exists("b:current_syntax")
+    finish
 endif

-syn case match
-
-
-" Catch incorrect syntax (only matches if nothing else does)
-"
-syn match bbUnmatched		"."
-
-
-" Other
-
-syn match bbComment		"^#.*$" display contains=bbTodo
-syn keyword bbTodo		TODO FIXME XXX contained
-syn match bbDelimiter		"[(){}=]" contained
-syn match bbQuote		/['"]/ contained
-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
-
-
-" 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 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
-
-
-" BitBake variable metadata flags
-syn match bbVarFlagDef		"^\([a-zA-Z0-9\-_\.]\+\)\(\[[a-zA-Z0-9\-_\.]\+\]\)\@=" contains=bbIdentifier nextgroup=bbVarFlagFlag
-syn region bbVarFlagFlag	matchgroup=bbArrayBrackets start="\[" end="\]\s*\(=\)\@=" keepend excludenl contained contains=bbIdentifier nextgroup=bbVarEq
-"syn match bbVarFlagFlag		"\[\([a-zA-Z0-9\-_\.]\+\)\]\s*\(=\)\@=" contains=bbIdentifier nextgroup=bbVarEq
-
-
-" Functions!
-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
-syn region bbPythonFuncRegion	matchgroup=bbDelimiter start="{\s*$" end="^}\s*$" keepend contained contains=@python
-"hi def link bbPythonFuncRegion	Comment
+" BitBake syntax

+" Matching case
+syn case match
+
+" Indicates the error when nothing is matched
+syn match bbUnmatched           "."
+
+" Comments
+syn cluster bbCommentGroup      contains=bbTodo,@Spell
+syn keyword bbTodo              COMBAK FIXME TODO XXX contained
+syn match bbComment             "#.*$" contains=@bbCommentGroup
+
+" String helpers
+syn match bbQuote               +['"]+ contained 
+syn match bbDelimiter           "[(){}=]" contained
+syn match bbArrayBrackets       "[\[\]]" contained
+
+" BitBake strings
+syn match bbContinue            "\\$"
+syn region bbString             matchgroup=bbQuote start=+"+ skip=+\\$+ excludenl end=+"+ contained keepend contains=bbTodo,bbContinue,bbVarDeref,bbVarPyValue,@Spell
+syn region bbString             matchgroup=bbQuote start=+'+ skip=+\\$+ excludenl end=+'+ contained keepend contains=bbTodo,bbContinue,bbVarDeref,bbVarPyValue,@Spell
+
+" Vars definition
+syn match bbExport            "^export" nextgroup=bbIdentifier skipwhite
+syn keyword bbExportFlag        export contained nextgroup=bbIdentifier skipwhite
+syn match bbIdentifier          "[a-zA-Z0-9\-_\.\/\+]\+" display contained
+syn match bbVarDeref            "${[a-zA-Z0-9\-_\.\/\+]\+}" contained
+syn match bbVarEq               "\(:=\|+=\|=+\|\.=\|=\.\|?=\|=\)" contained nextgroup=bbVarValue
+syn match bbVarDef              "^\(export\s*\)\?\([a-zA-Z0-9\-_\.\/\+]\+\(_[${}a-zA-Z0-9\-_\.\/\+]\+\)\?\)\s*\(:=\|+=\|=+\|\.=\|=\.\|?=\|=\)\@=" contains=bbExportFlag,bbIdentifier,bbVarDeref nextgroup=bbVarEq
+syn match bbVarValue            ".*$" contained contains=bbString,bbVarDeref,bbVarPyValue
+syn region bbVarPyValue         start=+${@+ skip=+\\$+ excludenl end=+}+ contained contains=@python
+
+" Vars metadata flags
+syn match bbVarFlagDef          "^\([a-zA-Z0-9\-_\.]\+\)\(\[[a-zA-Z0-9\-_\.]\+\]\)\@=" contains=bbIdentifier nextgroup=bbVarFlagFlag
+syn region bbVarFlagFlag        matchgroup=bbArrayBrackets start="\[" end="\]\s*\(=\)\@=" keepend excludenl contained contains=bbIdentifier nextgroup=bbVarEq
+
+" Includes and requires
+syn keyword bbInclude           inherit include require contained 
+syn match bbIncludeRest         ".*$" contained contains=bbString,bbVarDeref
+syn match bbIncludeLine         "^\(inherit\|include\|require\)\s\+" contains=bbInclude nextgroup=bbIncludeRest
+
+" Add taks and similar
+syn keyword bbStatement         addtask addhandler after before EXPORT_FUNCTIONS contained
+syn match bbStatementRest       ".*$" skipwhite contained contains=bbStatement
+syn match bbStatementLine       "^\(addtask\|addhandler\|after\|before\|EXPORT_FUNCTIONS\)\s\+" contains=bbStatement nextgroup=bbStatementRest
+
+" OE Important Functions
+syn keyword bbOEFunctions       do_fetch do_unpack do_patch do_configure do_compile do_stage do_install do_package contained
+
+" Generic Functions
+syn match bbFunction            "\h[0-9A-Za-z_-]*" display contained contains=bbOEFunctions

 " BitBake shell metadata
 syn include @shell syntax/sh.vim
 if exists("b:current_syntax")
  unlet b:current_syntax
 endif
+syn keyword bbShFakeRootFlag    fakeroot contained
+syn match bbShFuncDef           "^\(fakeroot\s*\)\?\([0-9A-Za-z_-]\+\)\(python\)\@<!\(\s*()\s*\)\({\)\@=" contains=bbShFakeRootFlag,bbFunction,bbDelimiter nextgroup=bbShFuncRegion skipwhite
+syn region bbShFuncRegion       matchgroup=bbDelimiter start="{\s*$" end="^}\s*$" keepend contained contains=@shell

-syn keyword bbFakerootFlag	fakeroot contained nextgroup=bbFunction
-syn match bbShellFuncDef	"^\(fakeroot\s*\)\?\(\w\+\)\(python\)\@<!\(\s*()\s*\)\({\)\@=" contains=bbFakerootFlag,bbFunction,bbDelimiter nextgroup=bbShellFuncRegion skipwhite
-syn region bbShellFuncRegion	matchgroup=bbDelimiter start="{\s*$" end="^}\s*$" keepend contained contains=@shell
-"hi def link bbShellFuncRegion	Comment
-
+" BitBake python metadata
+syn keyword bbPyFlag            python contained
+syn match bbPyFuncDef           "^\(python\s\+\)\([0-9A-Za-z_-]\+\)\?\(\s*()\s*\)\({\)\@=" contains=bbPyFlag,bbFunction,bbDelimiter nextgroup=bbPyFuncRegion skipwhite 
+syn region bbPyFuncRegion       matchgroup=bbDelimiter start="{\s*$" end="^}\s*$" keepend contained contains=@python

 " BitBake 'def'd python functions
-syn keyword bbDef	def	contained
-syn region bbDefRegion		start='^def\s\+\w\+\s*([^)]*)\s*:\s*$' end='^\(\s\|$\)\@!' contains=@python
+syn keyword bbPyDef             def contained
+syn region bbPyDefRegion        start='^\(def\s\+\)\([0-9A-Za-z_-]\+\)\(\s*(.*)\s*\):\s*$' end='^\(\s\|$\)\@!' contains=@python

-
-" BitBake statements
-syn keyword bbStatement		include inherit require addtask addhandler EXPORT_FUNCTIONS display contained
-syn match bbStatementLine	"^\(include\|inherit\|require\|addtask\|addhandler\|EXPORT_FUNCTIONS\)\s\+" contains=bbStatement nextgroup=bbStatementRest
-syn match bbStatementRest		".*$" contained contains=bbString,bbVarDeref
-
-" Highlight
-"
-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
-hi def link bbExportFlag	Type
-hi def link bbFakerootFlag	Type
-hi def link bbStatement		Statement
-hi def link bbString		String
-hi def link bbTodo		Todo
-hi def link bbComment		Comment
-hi def link bbOperator		Operator
-hi def link bbError		Error
-hi def link bbFunction		Function
-hi def link bbDelimiter		Delimiter
-hi def link bbIdentifier	Identifier
-hi def link bbVarEq		Operator
-hi def link bbQuote		String
-hi def link bbVarValue		String
+" Highlighting Definitions
+hi def link bbUnmatched         Error
+hi def link bbInclude           Include
+hi def link bbTodo              Todo
+hi def link bbComment           Comment
+hi def link bbQuote             String
+hi def link bbString            String
+hi def link bbDelimiter         Keyword
+hi def link bbArrayBrackets     Statement
+hi def link bbContinue          Special
+hi def link bbExport            Type
+hi def link bbExportFlag        Type
+hi def link bbIdentifier	    Identifier
+hi def link bbVarDeref          PreProc
+hi def link bbVarDef            Identifier
+hi def link bbVarValue          String
+hi def link bbShFakeRootFlag    Type
+hi def link bbFunction          Function
+hi def link bbPyFlag            Type
+hi def link bbPyDef             Statement
+hi def link bbStatement         Statement
+hi def link bbStatementRest     Identifier
+hi def link bbOEFunctions       Special
+hi def link bbVarPyValue        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.
@@ -67,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 
@@ -85,9 +85,6 @@ don't execute, just go through the motions
 .B \-p, \-\-parse-only
 quit after parsing the BB files (developers only)
 .TP
-.B \-d, \-\-disable-psyco
-disable using the psyco just-in-time compiler (not recommended)
-.TP
 .B \-s, \-\-show-versions
 show current and preferred versions of all packages
 .TP
--- a/bitbake/doc/manual/Makefile
+++ b/bitbake/doc/manual/Makefile
@@ -45,7 +45,7 @@ endif
 	$(call command,xsltproc --stringparam base.dir $@/ $(if $(htmlcssfile),--stringparam html.stylesheet $(htmlcssfile)) $(htmlxsl) $(manual),XSLTPROC $@ $(manual))

 $(xmltotypes): $(manual)
-	$(call command,xmlto --extensions -o $(topdir)/$@ $@ $(manual),XMLTO $@ $(manual))
+	$(call command,xmlto --with-dblatex --extensions -o $(topdir)/$@ $@ $(manual),XMLTO $@ $(manual))

 clean:
 	rm -rf $(cleanfiles)
--- a/bitbake/doc/manual/usermanual.xml
+++ b/bitbake/doc/manual/usermanual.xml
@@ -12,9 +12,10 @@
            <corpauthor>BitBake Team</corpauthor>
        </authorgroup>
        <copyright>
-            <year>2004, 2005, 2006</year>
+            <year>2004, 2005, 2006, 2011</year>
            <holder>Chris Larson</holder>
            <holder>Phil Blundell</holder>
+            <holder>Richard Purdie</holder>
        </copyright>
        <legalnotice>
            <para>This work is licensed under the Creative Commons Attribution License. To view a copy of this license, visit <ulink url="http://creativecommons.org/licenses/by/2.5/">http://creativecommons.org/licenses/by/2.5/</ulink> or send a letter to Creative Commons, 559 Nathan Abbott Way, Stanford, California 94305, USA.</para>
@@ -26,10 +27,10 @@
            <title>Overview</title>
            <para>BitBake is, at its simplest, a tool for executing
 tasks and managing metadata.  As such, its similarities to GNU make and other
-build tools are readily apparent.  It was inspired by Portage, the package management system used by the Gentoo Linux distribution.  BitBake is the basis of the <ulink url="http://www.openembedded.org/">OpenEmbedded</ulink> project, which is being used to build and maintain a number of embedded Linux distributions, including OpenZaurus and Familiar.</para>
+build tools are readily apparent.  It was inspired by Portage, the package management system used by the Gentoo Linux distribution.  BitBake is the basis of the <ulink url="http://www.openembedded.org/">OpenEmbedded</ulink> project, which is being used to build and maintain a number of embedded Linux distributions/projects such as Angstrom and the Yocto project.</para>
        </section>
        <section>
-            <title>Background and Goals</title>
+            <title>Background and goals</title>
            <para>Prior to BitBake, no other build tool adequately met
 the needs of an aspiring embedded Linux distribution.  All of the
 buildsystems used by traditional desktop Linux distributions lacked
@@ -37,14 +38,14 @@ important functionality, and none of the ad-hoc
 <emphasis>buildroot</emphasis> systems, prevalent in the
 embedded space, were scalable or maintainable.</para>

-      <para>Some important goals for BitBake were:
+      <para>Some important original goals for BitBake were:
            <itemizedlist>
                <listitem><para>Handle crosscompilation.</para></listitem>
                <listitem><para>Handle interpackage dependencies (build time on target architecture, build time on native architecture, and runtime).</para></listitem>
                <listitem><para>Support running any number of tasks within a given package, including, but not limited to, fetching upstream sources, unpacking them, patching them, configuring them, et cetera.</para></listitem>
-                <listitem><para>Must be linux distribution agnostic (both build and target).</para></listitem>
+                <listitem><para>Must be Linux distribution agnostic (both build and target).</para></listitem>
                <listitem><para>Must be architecture agnostic</para></listitem>
-                <listitem><para>Must support multiple build and target operating systems (including cygwin, the BSDs, etc).</para></listitem>
+                <listitem><para>Must support multiple build and target operating systems (including Cygwin, the BSDs, etc).</para></listitem>
                <listitem><para>Must be able to be self contained, rather than tightly integrated into the build machine's root filesystem.</para></listitem>
                <listitem><para>There must be a way to handle conditional metadata (on target architecture, operating system, distribution, machine).</para></listitem>
                <listitem><para>It must be easy for the person using the tools to supply their own local metadata and packages to operate against.</para></listitem>
@@ -53,10 +54,18 @@ between multiple projects using BitBake for their
 builds.</para></listitem>
 		<listitem><para>Should provide an inheritance mechanism to
 share common metadata between many packages.</para></listitem>
-                <listitem><para>Et cetera...</para></listitem>
            </itemizedlist>
        </para>
-        <para>BitBake satisfies all these and many more.  Flexibility and power have always been the priorities.  It is highly extensible, supporting embedded Python code and execution of any arbitrary tasks.</para>
+        <para>Over time it has become apparent that some further requirements were necessary:
+            <itemizedlist>
+                <listitem><para>Handle variants of a base recipe (native, sdk, multilib).</para></listitem>
+                <listitem><para>Able to split metadata into layers and allow layers to override each other.</para></listitem>
+                <listitem><para>Allow representation of a given set of input variables to a task as a checksum.</para></listitem>
+                <listitem><para>based on that checksum, allow acceleration of builds with prebuilt components.</para></listitem>
+            </itemizedlist>
+        </para>
+
+        <para>BitBake satisfies all the original requirements and many more with extensions being made to the basic functionality to reflect the additionl requirements.  Flexibility and power have always been the priorities.  It is highly extensible, supporting embedded Python code and execution of any arbitrary tasks.</para>
        </section>
    </chapter>
    <chapter>
@@ -88,6 +97,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 its 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 weak default value (??=)</title>
+                <para><screen><varname>A</varname> ??= "somevalue"
+<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/weak assignment 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. Any other setting of A using = or ?= will however override the value set with ??=</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>
@@ -114,12 +134,12 @@ share common metadata between many packages.</para></listitem>
 <varname>B</varname> .= "additionaldata"
 <varname>C</varname> = "cval"
 <varname>C</varname> =. "test"</screen></para>
-                <para>In this example, <varname>B</varname> is now <literal>bvaladditionaldata</literal> and <varname>C</varname> is <literal>testcval</literal>. In contrast to the above Appending and Prepending operators no additional space
+                <para>In this example, <varname>B</varname> is now <literal>bvaladditionaldata</literal> and <varname>C</varname> is <literal>testcval</literal>. In contrast to the above appending and prepending operators, no additional space
 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"
@@ -136,12 +156,12 @@ will be introduced.</para>
            </section>
            <section>
                <title>Inclusion</title>
-                <para>Next, there is the <literal>include</literal> directive, which causes BitBake to parse in whatever file you specify, and insert it at that location, which is not unlike <command>make</command>.  However, if the path specified on the <literal>include</literal> line is a relative path, BitBake will locate the first one it can find within <envar>BBPATH</envar>.</para>
+                <para>Next, there is the <literal>include</literal> directive, which causes BitBake to parse whatever file you specify, and insert it at that location, which is not unlike <command>make</command>.  However, if the path specified on the <literal>include</literal> line is a relative path, BitBake will locate the first one it can find within <envar>BBPATH</envar>.</para>
            </section>
            <section>
-                <title>Requiring Inclusion</title>
+                <title>Requiring inclusion</title>
                <para>In contrast to the <literal>include</literal> directive, <literal>require</literal> will
-raise an ParseError if the to be included file can not be found. Otherwise it will behave just like the <literal>
+raise an ParseError if the file to be included cannot be found. Otherwise it will behave just like the <literal>
 include</literal> directive.</para>
            </section>
            <section>
@@ -160,10 +180,10 @@ include</literal> directive.</para>
    import time
    print time.strftime('%Y%m%d', time.gmtime())
 }</screen></para>
-                <para>This is the similar to the previous, but flags it as python so that BitBake knows it is python code.</para>
+                <para>This is the similar to the previous, but flags it as Python so that BitBake knows it is Python code.</para>
            </section>
            <section>
-                <title>Defining python functions into the global python namespace</title>
+                <title>Defining Python functions into the global Python namespace</title>
                <para><emphasis>NOTE:</emphasis> This is only supported in .bb and .bbclass files.</para>
                <para><screen>def get_depends(bb, d):
    if bb.data.getVar('SOMECONDITION', d, True):
@@ -176,51 +196,119 @@ include</literal> directive.</para>
                <para>This would result in <varname>DEPENDS</varname> containing <literal>dependencywithcond</literal>.</para>
            </section>
            <section>
-                <title>Variable Flags</title>
-                <para>Variables can have associated flags which provide a way of tagging extra information onto a variable. Several flags are used internally by bitbake but they can be used externally too if needed. The standard operations mentioned above also work on flags.</para>
+                <title>Variable flags</title>
+                <para>Variables can have associated flags which provide a way of tagging extra information onto a variable. Several flags are used internally by BitBake but they can be used externally too if needed. The standard operations mentioned above also work on flags.</para>
                <para><screen><varname>VARIABLE</varname>[<varname>SOMEFLAG</varname>] = "value"</screen></para>
                <para>In this example, <varname>VARIABLE</varname> has a flag, <varname>SOMEFLAG</varname> which is set to <literal>value</literal>.</para>
            </section>
            <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>
                <para><emphasis>NOTE:</emphasis> This is only supported in .bb and .bbclass files.</para>
-                <para>In BitBake, each step that needs to be run for a given .bb is known as a task.  There is a command <literal>addtask</literal> to add new tasks (must be a defined python executable metadata and must start with <quote>do_</quote>) and describe intertask dependencies.</para>
+                <para>In BitBake, each step that needs to be run for a given .bb is known as a task.  There is a command <literal>addtask</literal> to add new tasks (must be a defined Python executable metadata and must start with <quote>do_</quote>) and describe intertask dependencies.</para>
                <para><screen>python do_printdate () {
    import time
    print time.strftime('%Y%m%d', time.gmtime())
 }

 addtask printdate before do_build</screen></para>
-                <para>This defines the necessary python function and adds it as a task which is now a dependency of do_build (the default task).  If anyone executes the do_build task, that will result in do_printdate being run first.</para>
+                <para>This defines the necessary Python function and adds it as a task which is now a dependency of do_build, the default task.  If anyone executes the do_build task, that will result in do_printdate being run first.</para>
            </section>
+
+            <section>
+                <title>Task Flags</title>
+                <para>Tasks support a number of flags which control various functionality of the task. These are as follows:</para>
+                <para>'dirs' - directories which should be created before the task runs</para>
+                <para>'cleandirs' - directories which should created before the task runs but should be empty</para>
+                <para>'noexec' - marks the tasks as being empty and no execution required. These are used as dependency placeholders or used when added tasks need to be subsequently disabled.</para>
+                <para>'nostamp' - don't generate a stamp file for a task. This means the task is always rexecuted.</para>
+                <para>'fakeroot' - this task needs to be run in a fakeroot environment, obtained by adding the variables in FAKEROOTENV to the environment.</para>
+                <para>'umask' - the umask to run the task under.</para>
+                <para> For the 'deptask', 'rdeptask', 'recdeptask' and 'recrdeptask' flags please see the dependencies section.</para>
+            </section>
+
            <section>
                <title>Events</title>
                <para><emphasis>NOTE:</emphasis> This is only supported in .bb and .bbclass files.</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>BitBake allows installation of 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 is to make it easy to do things like email notification 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 used 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 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>Variable interaction: Worked Examples</title>
+            <para>Despite the documentation of the different forms of variable definition above, it can be hard to work out what happens when variable operators are combined. This section documents some common questions people have regarding the way variables interact.</para>
+
+            <section>
+                <title>Override and append ordering</title>
+
+                <para>There is often confusion about which order overrides and the various append operators take effect.</para>
+
+                <para><screen><varname>OVERRIDES</varname> = "foo"
+<varname>A_foo_append</varname> = "X"</screen></para>
+                <para>In this case, X is unconditionally appended to the variable <varname>A_foo</varname>. Since foo is an override, A_foo would then replace <varname>A</varname>.</para>
+
+                 <para><screen><varname>OVERRIDES</varname> = "foo"
+<varname>A</varname> = "X"
+<varname>A_append_foo</varname> = "Y"</screen></para>
+                <para>In this case, only when foo is in OVERRIDES, Y is appended to the variable <varname>A</varname> so the value of <varname>A</varname> would become XY (NB: no spaces are appended).</para>
+
+                <para><screen><varname>OVERRIDES</varname> = "foo"
+<varname>A_foo_append</varname> = "X"
+<varname>A_foo_append</varname> += "Y"</screen></para>
+                <para>This behaves as per the first case above, but the value of <varname>A</varname> would be "X Y" instead of just "X".</para>
+
+                <para><screen><varname>A</varname> = "1"
+<varname>A_append</varname> = "2"
+<varname>A_append</varname> = "3"
+<varname>A</varname> += "4"
+<varname>A</varname> .= "5"</screen></para>
+
+                <para>Would ultimately result in <varname>A</varname> taking the value "1 4523" since the _append operator executes at the same time as the expansion of other overrides.</para>
+
+            </section>
+            <section>
+                <title>Key Expansion</title>
+
+                <para>Key expansion happens at the data store finalisation time just before overrides are expanded.</para>
+
+                <para><screen><varname>A${B}</varname> = "X"
+<varname>B</varname> = "2"
+<varname>A2</varname> = "Y"</screen></para>
+                <para>So in this case <varname>A2</varname> would take the value of "X".</para>
+            </section>
+
        </section>
        <section>
-            <title>Dependency Handling</title>
-            <para>Bitbake 1.7.x onwards works with the metadata at the task level since this is optimal when dealing with multiple threads of execution. A robust method of specifing task dependencies is therefore needed. </para>
+            <title>Dependency handling</title>
+            <para>BitBake 1.7.x onwards works with the metadata at the task level since this is optimal when dealing with multiple threads of execution. A robust method of specifing task dependencies is therefore needed. </para>
            <section>
                <title>Dependencies internal to the .bb file</title>
                <para>Where the dependencies are internal to a given .bb file, the dependencies are handled by the previously detailed addtask directive.</para>
@@ -228,26 +316,26 @@ of the event and the content of the <varname>FILE</varname> variable.</para>

            <section>
                <title>DEPENDS</title>
-                <para>DEPENDS is taken to specify build time dependencies. The 'deptask' flag for tasks is used to signify the task of each DEPENDS which must have completed before that task can be executed.</para>
+                <para>DEPENDS lists build time dependencies. The 'deptask' flag for tasks is used to signify the task of each item listed in DEPENDS which must have completed before that task can be executed.</para>
                <para><screen>do_configure[deptask] = "do_populate_staging"</screen></para>
                <para>means the do_populate_staging task of each item in DEPENDS must have completed before do_configure can execute.</para>
            </section>
            <section>
                <title>RDEPENDS</title>
-                <para>RDEPENDS is taken to specify runtime dependencies. The 'rdeptask' flag for tasks is used to signify the task of each RDEPENDS which must have completed before that task can be executed.</para>
+                <para>RDEPENDS lists runtime dependencies. The 'rdeptask' flag for tasks is used to signify the task of each item listed in RDEPENDS which must have completed before that task can be executed.</para>
                <para><screen>do_package_write[rdeptask] = "do_package"</screen></para>
                <para>means the do_package task of each item in RDEPENDS must have completed before do_package_write can execute.</para>
            </section>
            <section>
                <title>Recursive DEPENDS</title>
-                <para>These are specified with the 'recdeptask' flag and is used signify the task(s) of each DEPENDS which must have completed before that task can be executed. It applies recursively so also, the DEPENDS of each item in the original DEPENDS must be met and so on.</para>
+                <para>These are specified with the 'recdeptask' flag and is used signify the task(s) of each DEPENDS which must have completed before that task can be executed. It applies recursively so the DEPENDS of each item in the original DEPENDS must be met and so on.</para>
            </section>
            <section>
                <title>Recursive RDEPENDS</title>
-                <para>These are specified with the 'recrdeptask' flag and is used signify the task(s) of each RDEPENDS which must have completed before that task can be executed. It applies recursively so also, the RDEPENDS of each item in the original RDEPENDS must be met and so on. It also runs all DEPENDS first too.</para>
+                <para>These are specified with the 'recrdeptask' flag and is used signify the task(s) of each RDEPENDS which must have completed before that task can be executed. It applies recursively so the RDEPENDS of each item in the original RDEPENDS must be met and so on. It also runs all DEPENDS first.</para>
            </section>
            <section>
-                <title>Inter Task</title>
+                <title>Inter task</title>
                <para>The 'depends' flag for tasks is a more generic form of which allows an interdependency on specific tasks rather than specifying the data in DEPENDS or RDEPENDS.</para>
                <para><screen>do_patch[depends] = "quilt-native:do_populate_staging"</screen></para>
                <para>means the do_populate_staging task of the target quilt-native must have completed before the do_patch can execute.</para>
@@ -257,33 +345,56 @@ of the event and the content of the <varname>FILE</varname> variable.</para>
        <section>
            <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>
+                <title>Configuration files</title>
+                <para>The first kind 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 directories 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>
+                <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 separated list of .bb files, and does handle wildcards.</para>
            </section>
        </section>
    </chapter>

    <chapter>
-        <title>File Download support</title>
+        <title>File download support</title>
        <section>
            <title>Overview</title>
-            <para>BitBake provides support to download files this procedure is called fetching. The SRC_URI is normally used to indicate BitBake which files to fetch. The next sections will describe th available fetchers and the options they have. Each Fetcher honors a set of Variables and
-a per URI parameters separated by a <quote>;</quote> consisting of a key and a value. The semantic of the Variables and Parameters are defined by the Fetcher. BitBakes tries to have a consistent semantic between the different Fetchers.
+            <para>BitBake provides support to download files this procedure is called fetching and it handled by the fetch and fetch2 modules. At this point the original fetch code is considered to be replaced by fetch2 and this manual only related to the fetch2 codebase.</para>
+
+            <para>The SRC_URI is normally used to tell BitBake which files to fetch. The next sections will describe the available fetchers and their options. Each fetcher honors a set of variables and per URI parameters separated by a <quote>;</quote> consisting of a key and a value. The semantics of the variables and parameters are defined by the fetcher. BitBake tries to have consistent semantics between the different fetchers.
            </para>
+
+            <para>The overall fetch process is that first, fetches are attempted from PREMIRRORS. If those don't work, the original SRC_URI is attempted and if that fails, BitBake will fall back to MIRRORS. Cross urls are supported, so its possible to mirror a git repository on an http server as a tarball for example. Some example commonly used mirror definitions are:</para>
+
+            <para><screen><varname>PREMIRRORS</varname> ?= "\
+bzr://.*/.*   http://somemirror.org/sources/ \n \
+cvs://.*/.*   http://somemirror.org/sources/ \n \
+git://.*/.*   http://somemirror.org/sources/ \n \
+hg://.*/.*    http://somemirror.org/sources/ \n \
+osc://.*/.*   http://somemirror.org/sources/ \n \
+p4://.*/.*    http://somemirror.org/sources/ \n \
+svk://.*/.*   http://somemirror.org/sources/ \n \
+svn://.*/.*   http://somemirror.org/sources/ \n"
+
+<varname>MIRRORS</varname> =+ "\
+ftp://.*/.*      http://somemirror.org/sources/ \n \
+http://.*/.*     http://somemirror.org/sources/ \n \
+https://.*/.*    http://somemirror.org/sources/ \n"</screen></para>
+
+            <para>Non-local downloaded output is placed into the directory specified by the <varname>DL_DIR</varname>. For non local downloads the code can check checksums for the download to ensure the file has been downloaded correctly. These are specified in the form <varname>SRC_URI[md5sum]</varname> for the md5 checksum and <varname>SRC_URI[sha256sum]</varname> for the sha256 checksum. If <varname>BB_STRICT_CHECKSUM</varname> is set, any download without a checksum will trigger an error message. In cases where multiple files are listed in SRC_URI, the name parameter is used assign names to the urls and these are then specified in the checksums in the form SRC_URI[name.sha256sum].</para>
+
        </section>

        <section>
-            <title>Local File Fetcher</title>
-            <para>The URN for the Local File Fetcher is <emphasis>file</emphasis>. The filename can be either absolute or relative. If the filename is relative <varname>FILESPATH</varname> and <varname>FILESDIR</varname> will be used to find the appropriate relative file depending on the <varname>OVERRIDES</varname>. Single files and complete directories can be specified.
+            <title>Local file fetcher</title>
+            <para>The URN for the local file fetcher is <emphasis>file</emphasis>. The filename can be either absolute or relative. If the filename is relative, <varname>FILESPATH</varname> and failing that <varname>FILESDIR</varname> will be used to find the appropriate relative file. The metadata usually extend these variables to include variations of the values in <varname>OVERRIDES</varname>. Single files and complete directories can be specified.
 <screen><varname>SRC_URI</varname>= "file://relativefile.patch"
 <varname>SRC_URI</varname>= "file://relativefile.patch;this=ignored"
 <varname>SRC_URI</varname>= "file:///Users/ich/very_important_software"
@@ -292,10 +403,11 @@ a per URI parameters separated by a <quote>;</quote> consisting of a key and a v
        </section>

        <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.
+            <title>CVS fetcher</title>
+            <para>The URN for the CVS fetcher is <emphasis>cvs</emphasis>. This fetcher honors the variables <varname>CVSDIR</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 to use for 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> and <varname>scmdata</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>
@@ -303,32 +415,22 @@ a per URI parameters separated by a <quote>;</quote> consisting of a key and a v
        </section>

        <section>
-            <title>HTTP/FTP Fetcher</title>
-            <para>The URNs for the HTTP/FTP are <emphasis>http</emphasis>, <emphasis>https</emphasis> and <emphasis>ftp</emphasis>. This Fetcher honors the variables <varname>DL_DIR</varname>, <varname>FETCHCOMMAND_wget</varname>, <varname>PREMIRRORS</varname>, <varname>MIRRORS</varname>. The <varname>DL_DIR</varname> defines where to store the fetched file, <varname>FETCHCOMMAND</varname> contains the command used for fetching. <quote>${URI}</quote> and <quote>${FILES}</quote> will be replaced by the uri and basename of the to be fetched file. <varname>PREMIRRORS</varname>
-will be tried first when fetching a file if that fails the actual file will be tried and finally all <varname>MIRRORS</varname> will be tried.
+            <title>HTTP/FTP fetcher</title>
+            <para>The URNs for the HTTP/FTP fetcher are <emphasis>http</emphasis>, <emphasis>https</emphasis> and <emphasis>ftp</emphasis>. This fetcher honors the variables <varname>FETCHCOMMAND_wget</varname>. <varname>FETCHCOMMAND</varname> contains the command used for fetching. <quote>${URI}</quote> and <quote>${FILES}</quote> will be replaced by the URI and basename of the file to be fetched.
            </para>
-            <para>The only supported Parameter is <varname>md5sum</varname>. After a fetch the <varname>md5sum</varname> of the file will be calculated and the two sums will be compared.
-            </para>
-            <para><screen><varname>SRC_URI</varname> = "http://oe.handhelds.org/not_there.aac;md5sum=12343"
-<varname>SRC_URI</varname> = "ftp://oe.handhelds.org/not_there_as_well.aac;md5sum=1234"
-<varname>SRC_URI</varname> = "ftp://you@oe.handheld.sorg/home/you/secret.plan;md5sum=1234"
+            <para><screen><varname>SRC_URI</varname> = "http://oe.handhelds.org/not_there.aac"
+<varname>SRC_URI</varname> = "ftp://oe.handhelds.org/not_there_as_well.aac"
+<varname>SRC_URI</varname> = "ftp://you@oe.handheld.sorg/home/you/secret.plan"
 </screen></para>
        </section>

        <section>
-            <title>SVK Fetcher</title>
-            <para>
-            <emphasis>Currently NOT supported</emphasis>
+            <title>SVN fetcher</title>
+            <para>The URN for the SVN fetcher is <emphasis>svn</emphasis>.
            </para>
-        </section>
-
-        <section>
-            <title>SVN Fetcher</title>
-            <para>The URN for the SVN Fetcher is <emphasis>svn</emphasis>.
+            <para>This fetcher honors the variables <varname>FETCHCOMMAND_svn</varname>, <varname>SVNDIR</varname>, <varname>SRCREV</varname>. <varname>FETCHCOMMAND</varname> contains the subversion command. <varname>SRCREV</varname> specifies which revision to use when doing the fetching.
            </para>
-            <para>This Fetcher honors the variables <varname>FETCHCOMMAND_svn</varname>, <varname>DL_DIR</varname>, <varname>SRCDATE</varname>. <varname>FETCHCOMMAND</varname> contains the subversion command, <varname>DL_DIR</varname> is the directory where tarballs will be 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).
-            </para>
-            <para>The supported Parameters are <varname>proto</varname>, <varname>rev</varname>. <varname>proto</varname> is the subversion prototype, <varname>rev</varname> is the subversions revision.
+            <para>The supported parameters are <varname>proto</varname>, <varname>rev</varname> and <varname>scmdata</varname>. <varname>proto</varname> is the Subversion protocol, <varname>rev</varname> is the Subversion revision. If <varname>scmdata</varname> is set to <quote>keep</quote>, the <quote>.svn</quote> directories will be available during compile-time.
            </para>
            <para><screen><varname>SRC_URI</varname> = "svn://svn.oe.handhelds.org/svn;module=vip;proto=http;rev=667"
 <varname>SRC_URI</varname> = "svn://svn.oe.handhelds.org/svn/;module=opie;proto=svn+ssh;date=20060126"
@@ -336,12 +438,12 @@ will be tried first when fetching a file if that fails the actual file will be t
        </section>

        <section>
-            <title>GIT Fetcher</title>
+            <title>GIT fetcher</title>
            <para>The URN for the GIT Fetcher is <emphasis>git</emphasis>.
            </para>
-            <para>The Variables <varname>DL_DIR</varname>, <varname>GITDIR</varname> are used. <varname>DL_DIR</varname> will be used to store the checkedout version. <varname>GITDIR</varname> will be used as the base directory where the git tree is cloned to.
+            <para>The variable <varname>GITDIR</varname> will be used as the base directory where the git tree is cloned to.
            </para>
-            <para>The Parameters are <emphasis>tag</emphasis>, <emphasis>protocol</emphasis>. <emphasis>tag</emphasis> is a git tag, the default is <quote>master</quote>. <emphasis>protocol</emphasis> is the git protocol to use and defaults to <quote>rsync</quote>.
+            <para>The parameters are <emphasis>tag</emphasis>, <emphasis>protocol</emphasis> and <emphasis>scmdata</emphasis>. <emphasis>tag</emphasis> is a Git tag, the default is <quote>master</quote>. <emphasis>protocol</emphasis> is the Git protocol to use and defaults to <quote>git</quote> if a hostname is set, otherwise its <quote>file</quote>. If <emphasis>scmdata</emphasis> is set to <quote>keep</quote>, the <quote>.git</quote> directory will be available during compile-time.
            </para>
            <para><screen><varname>SRC_URI</varname> = "git://git.oe.handhelds.org/git/vip.git;tag=version-1"
 <varname>SRC_URI</varname> = "git://git.oe.handhelds.org/git/vip.git;protocol=http"
@@ -352,27 +454,19 @@ 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>
            </section>
            <section>
-                <title>Usage and Syntax</title>
+                <title>Usage and syntax</title>
                <para>
                    <screen><prompt>$ </prompt>bitbake --help
 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 +488,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
@@ -402,8 +496,6 @@ options:
                        than once.
  -n, --dry-run         don't execute, just go through the motions
  -p, --parse-only      quit after parsing the BB files (developers only)
-  -d, --disable-psyco   disable using the psyco just-in-time compiler (not
-                        recommended)
  -s, --show-versions   show current and preferred versions of all packages
  -e, --environment     show the global or per-package environment (this is
                        what used to be bbread)
@@ -417,12 +509,13 @@ options:
                        Show debug logging for the specified logging domains
  -P, --profile         profile the command and print a report

+
 </screen>
                </para>
                <para>
                <example>
                    <title>Executing a task against a single .bb</title>
-                    <para>Executing tasks for a single file is relatively simple.  You specify the file in question, and bitbake parses it and executes the specified task (or <quote>build</quote> by default).  It obeys intertask dependencies when doing so.</para>
+                    <para>Executing tasks for a single file is relatively simple.  You specify the file in question, and BitBake parses it and executes the specified task (or <quote>build</quote> by default).  It obeys intertask dependencies when doing so.</para>
                    <para><quote>clean</quote> task:</para>
                    <para><screen><prompt>$ </prompt>bitbake -b blah_1.0.bb -c clean</screen></para>
                    <para><quote>build</quote> task:</para>
@@ -432,8 +525,8 @@ options:
                <para>
                <example>
                    <title>Executing tasks against a set of .bb files</title>
-                    <para>There are a number of additional complexities introduced when one wants to manage multiple .bb files.  Clearly there needs to be a way to tell bitbake what files are available, and of those, which we want to execute at this time.  There also needs to be a way for each .bb to express its dependencies, both for build time and runtime.  There must be a way for the user to express their preferences when multiple .bb's provide the same functionality, or when there are multiple versions of a .bb.</para>
-                    <para>The next section, Metadata, outlines how one goes about specifying such things.</para>
+                    <para>There are a number of additional complexities introduced when one wants to manage multiple .bb files.  Clearly there needs to be a way to tell BitBake what files are available, and of those, which we want to execute at this time.  There also needs to be a way for each .bb to express its dependencies, both for build time and runtime.  There must be a way for the user to express their preferences when multiple .bb's provide the same functionality, or when there are multiple versions of a .bb.</para>
+                    <para>The next section, Metadata, outlines how to specify such things.</para>
                    <para>Note that the bitbake command, when not using --buildfile, accepts a <varname>PROVIDER</varname>, not a filename or anything else.  By default, a .bb generally PROVIDES its packagename, packagename-version, and packagename-version-revision.</para>
                    <screen><prompt>$ </prompt>bitbake blah</screen>
                    <screen><prompt>$ </prompt>bitbake blah-1.0</screen>
@@ -445,8 +538,8 @@ options:
                <example>
                    <title>Generating dependency graphs</title>
                    <para>BitBake is able to generate dependency graphs using the dot syntax. These graphs can be converted
-to images using the <application>dot</application> application from <ulink url="http://www.graphviz.org">graphviz</ulink>. 
-Two files will be written into the current working directory, <emphasis>depends.dot</emphasis> containing dependency information at the package level and <emphasis>task-depends.dot</emphasis> containing a breakdown of the dependencies at the task level. To stop depending on common depends one can use the <prompt>-I depend</prompt> to omit these from the graph. This can lead to more readable graphs. E.g. this way <varname>DEPENDS</varname> from inherited classes, e.g. base.bbclass, can be removed from the graph.</para>
+to images using the <application>dot</application> application from <ulink url="http://www.graphviz.org">Graphviz</ulink>. 
+Two files will be written into the current working directory, <emphasis>depends.dot</emphasis> containing dependency information at the package level and <emphasis>task-depends.dot</emphasis> containing a breakdown of the dependencies at the task level. To stop depending on common depends, one can use the <prompt>-I depend</prompt> to omit these from the graph. This can lead to more readable graphs.  This way, <varname>DEPENDS</varname> from inherited classes such as base.bbclass can be removed from the graph.</para>
                    <screen><prompt>$ </prompt>bitbake -g blah</screen>
                    <screen><prompt>$ </prompt>bitbake -g -I virtual/whatever -I bloom blah</screen>
                </example>
@@ -454,20 +547,20 @@ Two files will be written into the current working directory, <emphasis>depends.
            </section>
            <section>
                <title>Special variables</title>
-                <para>Certain variables affect bitbake operation:</para>
+                <para>Certain variables affect BitBake operation:</para>
                <section>
                    <title><varname>BB_NUMBER_THREADS</varname></title>
-                    <para> The number of threads bitbake should run at once (default: 1).</para>
+                    <para> The number of threads BitBake should run at once (default: 1).</para>
                </section>
            </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 <varname>BBFILES</varname> 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, set to a component of the .bb filename by default.</para>
                <example>
                    <title>Depending on another .bb</title>
                    <para>a.bb:
@@ -480,7 +573,7 @@ DEPENDS += "package-b"</screen>
                </example>
                <example>
                    <title>Using PROVIDES</title>
-                    <para>This example shows the usage of the PROVIDES variable, which allows a given .bb to specify what functionality it provides.</para>
+                    <para>This example shows the usage of the <varname>PROVIDES</varname> variable, which allows a given .bb to specify what functionality it provides.</para>
                    <para>package1.bb:
    <screen>PROVIDES += "virtual/package"</screen>
                    </para>
@@ -490,16 +583,16 @@ DEPENDS += "package-b"</screen>
                    <para>package3.bb:
    <screen>PROVIDES += "virtual/package"</screen>
                    </para>
-                    <para>As you can see, here there are two different .bb's that provide the same functionality (virtual/package).  Clearly, there needs to be a way for the person running bitbake to control which of those providers gets used.  There is, indeed, such a way.</para>
+                    <para>As you can see, we have two different .bb's that provide the same functionality (virtual/package).  Clearly, there needs to be a way for the person running BitBake to control which of those providers gets used.  There is, indeed, such a way.</para>
                    <para>The following would go into a .conf file, to select package1:
    <screen>PREFERRED_PROVIDER_virtual/package = "package1"</screen>
                    </para>
                </example>
                <example>
                    <title>Specifying version preference</title>
-                    <para>When there are multiple <quote>versions</quote> of a given package, bitbake defaults to selecting the most recent version, unless otherwise specified.  If the .bb in question has a <varname>DEFAULT_PREFERENCE</varname> set lower than the other .bb's (default is 0), then it will not be selected.  This allows the person or persons maintaining the repository of .bb files to specify their preferences for the default selected version.  In addition, the user can specify their preferences with regard to version.</para>
+                    <para>When there are multiple <quote>versions</quote> of a given package, BitBake defaults to selecting the most recent version, unless otherwise specified.  If the .bb in question has a <varname>DEFAULT_PREFERENCE</varname> set lower than the other .bb's (default is 0), then it will not be selected.  This allows the person or persons maintaining the repository of .bb files to specify their preference for the default selected version.  In addition, the user can specify their preferred version.</para>
                    <para>If the first .bb is named <filename>a_1.1.bb</filename>, then the <varname>PN</varname> variable will be set to <quote>a</quote>, and the <varname>PV</varname> variable will be set to 1.1.</para>
-                    <para>If we then have an <filename>a_1.2.bb</filename>, bitbake will choose 1.2 by default.  However, if we define the following variable in a .conf that bitbake parses, we can change that.
+                    <para>If we then have an <filename>a_1.2.bb</filename>, BitBake will choose 1.2 by default.  However, if we define the following variable in a .conf that BitBake parses, we can change that.
    <screen>PREFERRED_VERSION_a = "1.1"</screen>
                    </para>
                </example>
@@ -514,6 +607,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
-types.ImmutableTypes = tuple([ \
-    types.BooleanType, \
-    types.ComplexType, \
-    types.FloatType, \
-    types.IntType, \
-    types.LongType, \
-    types.NoneType, \
-    types.TupleType, \
-    frozenset] + \
-    list(types.StringTypes))
+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,32 +25,54 @@
 #
 #Based on functions from the base bb module, Copyright 2003 Holger Schurig

-from bb import data, fetch, event, mkdirhier, utils
-import bb, os
+import os
+import sys
+import logging
+import shlex
+import bb
+import bb.msg
+import bb.process
+from contextlib import nested
+from bb import data, event, utils

-# When we execute a python function we'd like certain things 
+bblogger = logging.getLogger('BitBake')
+logger = logging.getLogger('BitBake.Build')
+
+NULL = open(os.devnull, 'r+')
+
+
+# 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"""
+    def __init__(self, name = None, logfile = None):
+        self.logfile = logfile
+        self.name = name
+        if name:
+            self.msg = "Function '%s' failed" % name
+        else:
+            self.msg = "Function failed"

-class EventException(Exception):
-    """Exception which is associated with an Event."""
-
-    def __init__(self, msg, event):
-        self.args = msg, event
+    def __str__(self):
+        if self.logfile and os.path.exists(self.logfile):
+            msg = ("%s (see %s for further information)" %
+                   (self.msg, self.logfile))
+        else:
+            msg = self.msg
+        return msg

 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
@@ -69,255 +91,313 @@ class TaskSucceeded(TaskBase):
 class TaskFailed(TaskBase):
    """Task execution failed"""

-class InvalidTask(TaskBase):
-    """Invalid Task"""
+    def __init__(self, task, logfile, metadata):
+        self.logfile = logfile
+        super(TaskFailed, self).__init__(task, metadata)
+
+class TaskInvalid(TaskBase):
+
+    def __init__(self, task, metadata):
+        super(TaskInvalid, self).__init__(task, metadata)
+        self._message = "No such task '%s'" % task
+
+
+class LogTee(object):
+    def __init__(self, logger, outfile):
+        self.outfile = outfile
+        self.logger = logger
+        self.name = self.outfile.name
+
+    def write(self, string):
+        self.logger.plain(string)
+        self.outfile.write(string)
+
+    def __enter__(self):
+        self.outfile.__enter__()
+        return self
+
+    def __exit__(self, *excinfo):
+        self.outfile.__exit__(*excinfo)
+
+    def __repr__(self):
+        return '<LogTee {0}>'.format(self.name)

-# functions

 def exec_func(func, d, dirs = None):
    """Execute an BB 'function'"""

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

    flags = data.getVarFlags(func, d)
-    for item in ['deps', 'check', 'interactive', 'python', 'cleandirs', 'dirs', 'lockfiles', 'fakeroot']:
-        if not item in flags:
-            flags[item] = None
+    cleandirs = flags.get('cleandirs')
+    if cleandirs:
+        for cdir in data.expand(cleandirs, d).split():
+            bb.utils.remove(cdir, True)

-    ispython = flags['python']
-
-    cleandirs = (data.expand(flags['cleandirs'], d) or "").split()
-    for cdir in cleandirs:
-        os.system("rm -rf %s" % cdir)
+    if dirs is None:
+        dirs = flags.get('dirs')
+        if dirs:
+            dirs = data.expand(dirs, d).split()

    if dirs:
-        dirs = data.expand(dirs, d)
-    else:
-        dirs = (data.expand(flags['dirs'], d) or "").split()
-    for adir in dirs:
-        mkdirhier(adir)
-
-    if len(dirs) > 0:
+        for adir in dirs:
+            bb.utils.mkdirhier(adir)
        adir = dirs[-1]
    else:
        adir = data.getVar('B', d, 1)
+        bb.utils.mkdirhier(adir)
+
+    ispython = flags.get('python')
+    if flags.get('fakeroot') and not flags.get('task'):
+        bb.fatal("Function %s specifies fakeroot but isn't a task?!" % func)
+
+    lockflag = flags.get('lockfiles')
+    if lockflag:
+        lockfiles = [data.expand(f, d) for f in lockflag.split()]
+    else:
+        lockfiles = None
+
+    tempdir = data.getVar('T', d, 1)
+    bb.utils.mkdirhier(tempdir)
+    runfile = os.path.join(tempdir, 'run.{0}.{1}'.format(func, os.getpid()))
+
+    with bb.utils.fileslocked(lockfiles):
+        if ispython:
+            exec_func_python(func, d, runfile, cwd=adir)
+        else:
+            exec_func_shell(func, d, runfile, cwd=adir)
+
+_functionfmt = """
+def {function}(d):
+{body}
+
+{function}(d)
+"""
+logformatter = bb.msg.BBLogFormatter("%(levelname)s: %(message)s")
+def exec_func_python(func, d, runfile, cwd=None):
+    """Execute a python BB 'function'"""
+
+    bbfile = d.getVar('FILE', True)
+    code = _functionfmt.format(function=func, body=d.getVar(func, True))
+    bb.utils.mkdirhier(os.path.dirname(runfile))
+    with open(runfile, 'w') as script:
+        script.write(code)
+
+    if cwd:
+        try:
+            olddir = os.getcwd()
+        except OSError:
+            olddir = None
+        os.chdir(cwd)

    try:
-        prevdir = os.getcwd()
-    except OSError:
-        prevdir = data.getVar('TOPDIR', d, True)
-    if adir and os.access(adir, os.F_OK):
-        os.chdir(adir)
+        comp = utils.better_compile(code, func, bbfile)
+        utils.better_exec(comp, {"d": d}, code, bbfile)
+    except:
+        if sys.exc_info()[0] in (bb.parse.SkipPackage, bb.build.FuncFailed):
+            raise

-    locks = []
-    lockfiles = (data.expand(flags['lockfiles'], d) or "").split()
-    for lock in lockfiles:
-        locks.append(bb.utils.lockfile(lock))
+        raise FuncFailed(func, None)
+    finally:
+        if cwd and olddir:
+            try:
+                os.chdir(olddir)
+            except OSError:
+                pass

-    if flags['python']:
-        exec_func_python(func, d)
-    else:
-        exec_func_shell(func, d, flags)
-
-    for lock in locks:
-        bb.utils.unlockfile(lock)
-
-    if os.path.exists(prevdir):
-        os.chdir(prevdir)
-
-def exec_func_python(func, d):
-    """Execute a python BB 'function'"""
-    import re
-
-    bbfile = bb.data.getVar('FILE', d, 1)
-    tmp  = "def " + func + "():\n%s" % data.getVar(func, d)
-    tmp += '\n' + func + '()'
-    comp = utils.better_compile(tmp, func, bbfile)
-    g = {} # globals
-    g['d'] = d
-    utils.better_exec(comp, g, tmp, bbfile)
-
-def exec_func_shell(func, d, 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
-    data into it and finally executes. The output of the shell will end in a log file and stdout.
+def exec_func_shell(function, d, runfile, cwd=None):
+    """Execute a shell function from the metadata

    Note on directory behavior.  The 'dirs' varflag should contain a list
    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 = flags['deps']
-    check = flags['check']
-    interact = flags['interactive']
-    if check in globals():
-        if globals()[check](func, deps):
-            return
+    # Don't let the emitted shell script override PWD
+    d.delVarFlag('PWD', 'export')

-    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()))
+    with open(runfile, 'w') as script:
+        script.write('#!/bin/sh -e\n')
+        if bb.msg.loggerDefaultVerbose:
+            script.write("set -x\n")
+        data.emit_func(function, script, d)
+        if cwd:
+            script.write("cd %s\n" % cwd)
+        script.write("%s\n" % function)

-    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)
-
-    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
+    cmd = runfile
+
+    if bb.msg.loggerDefaultVerbose:
+        logfile = LogTee(logger, sys.stdout)
+    else:
+        logfile = sys.stdout
+
+    try:
+        bb.process.run(cmd, shell=False, stdin=NULL, log=logfile)
+    except bb.process.CmdError:
+        logfn = d.getVar('BB_LOGFILE', True)
+        raise FuncFailed(function, logfn)
+
+def _task_data(fn, task, d):
+    localdata = data.createCopy(d)
+    localdata.setVar('BB_FILENAME', fn)
+    localdata.setVar('BB_CURRENTTASK', task[3:])
+    localdata.setVar('OVERRIDES', 'task-%s:%s' %
+                     (task[3:], d.getVar('OVERRIDES', False)))
+    localdata.finalize()
+    data.expandKeys(localdata)
+    return localdata
+
+def _exec_task(fn, task, d, quieterr):
+    """Execute a BB 'task'
+
+    Execution of a task involves a bit more setup than executing a function,
+    running it with its own local metadata, and with some useful variables set.
+    """
+    if not data.getVarFlag(task, 'task', d):
+        event.fire(TaskInvalid(task, d), d)
+        logger.error("No such task: %s" % task)
+        return 1
+
+    logger.debug(1, "Executing task %s", task)
+
+    localdata = _task_data(fn, task, d)
+    tempdir = localdata.getVar('T', True)
+    if not tempdir:
+        bb.fatal("T variable not set, unable to build")
+
+    bb.utils.mkdirhier(tempdir)
+    loglink = os.path.join(tempdir, 'log.{0}'.format(task))
+    logfn = os.path.join(tempdir, 'log.{0}.{1}'.format(task, os.getpid()))
+    if loglink:
+        bb.utils.remove(loglink)
+
+        try:
+           os.symlink(logfn, loglink)
+        except OSError:
+           pass
+
+    prefuncs = localdata.getVarFlag(task, 'prefuncs', expand=True)
+    postfuncs = localdata.getVarFlag(task, 'postfuncs', expand=True)
+
+    # Handle logfiles
    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)
+        logfile = file(logfn, 'w')
+    except OSError:
+        logger.exception("Opening log file '%s'", logfn)
        pass

-    se = so
+    # 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()]

-    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(logfile.fileno(), oso[1])
+    os.dup2(logfile.fileno(), ose[1])

-        # replace those fds with our own
-        os.dup2(si.fileno(), osi[1])
-        os.dup2(so.fileno(), oso[1])
-        os.dup2(se.fileno(), ose[1])
+    # Ensure python logging goes to the logfile
+    handler = logging.StreamHandler(logfile)
+    handler.setFormatter(logformatter)
+    # Always enable full debug output into task logfiles
+    handler.setLevel(logging.DEBUG - 2)
+    bblogger.addHandler(handler)

-    # execute function
-    prevdir = os.getcwd()
-    if flags['fakeroot']:
-        maybe_fakeroot = "PATH=\"%s\" fakeroot " % bb.data.getVar("PATH", d, 1)
-    else:
-        maybe_fakeroot = ''
-    lang_environment = "LC_ALL=C "
-    ret = os.system('%s%ssh -e %s' % (lang_environment, maybe_fakeroot, runfile))
+    localdata.setVar('BB_LOGFILE', logfn)
+
+    event.fire(TaskStarted(task, localdata), localdata)
    try:
-        os.chdir(prevdir)
-    except:
-        pass
+        for func in (prefuncs or '').split():
+            exec_func(func, localdata)
+        exec_func(task, localdata)
+        for func in (postfuncs or '').split():
+            exec_func(func, localdata)
+    except FuncFailed as exc:
+        if not quieterr:
+            logger.error(str(exc))
+            event.fire(TaskFailed(task, logfn, localdata), localdata)
+        return 1
+    finally:
+        sys.stdout.flush()
+        sys.stderr.flush()

-    if not interact:
-        # restore the backups
+        bblogger.removeHandler(handler)
+
+        # 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 os.path.getsize(logfile) == 0:
-            bb.msg.debug(2, bb.msg.domain.Build, "Zero size logfile %s, removing" % logfile)
-            os.remove(logfile)
-
-        # close the backup fds
+        # Close the backup fds
        os.close(osi[0])
        os.close(oso[0])
        os.close(ose[0])
+        si.close()

-    if ret==0:
-        if bb.msg.debug_level['default'] > 0:
-            os.remove(runfile)
-#            os.remove(logfile)
-        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 )
+        logfile.close()
+        if os.path.exists(logfn) and os.path.getsize(logfn) == 0:
+            logger.debug(2, "Zero size logfn %s, removing", logfn)
+            bb.utils.remove(logfn)
+            bb.utils.remove(loglink)
+    event.fire(TaskSucceeded(task, localdata), localdata)

+    if not localdata.getVarFlag(task, 'nostamp') and not localdata.getVarFlag(task, 'selfstamp'):
+        make_stamp(task, localdata)

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

-       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."""
+def exec_task(fn, task, d):
+    try: 
+        quieterr = False
+        if d.getVarFlag(task, "quieterrors") is not None:
+            quieterr = True

-    # Check whther this is a valid task
-    if not data.getVarFlag(task, 'task', d):
-        raise EventException("No such task", InvalidTask(task, d))
+        return _exec_task(fn, task, d, quieterr)
+    except Exception:
+        from traceback import format_exc
+        if not quieterr:
+            logger.error("Build of %s failed" % (task))
+            logger.error(format_exc())
+            failedevent = TaskFailed(task, None, d)
+            event.fire(failedevent, 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)
-        event.fire(TaskStarted(task, localdata))
-        exec_func(task, localdata)
-        event.fire(TaskSucceeded(task, localdata))
-    except FuncFailed, reason:
-        bb.msg.note(1, bb.msg.domain.Build, "Task failed: %s" % reason )
-        failedevent = TaskFailed(task, d)
-        event.fire(failedevent)
-        raise EventException("Function failed in task: %s" % reason, failedevent)
-
-    # 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)
-
-def extract_stamp(d, fn):
-    """
-    Extracts stamp format which is either a data dictonary (fn unset) 
-    or a dataCache entry (fn set). 
-    """
-    if fn:
-        return d.stamp[fn]
-    return data.getVar('STAMP', d, 1)
-
-def stamp_internal(task, d, file_name):
+def stamp_internal(taskname, d, file_name):
    """
    Internal stamp helper function
-    Removes any stamp for the given task
    Makes sure the stamp directory exists
    Returns the stamp path+filename
+
+    In the bitbake core, d can be a CacheData and file_name will be set.
+    When called in task context, d will be a data store, file_name will not be set
    """
-    stamp = extract_stamp(d, file_name)
+    taskflagname = taskname
+    if taskname.endswith("_setscene") and taskname != "do_setscene":
+        taskflagname = taskname.replace("_setscene", "")
+
+    if file_name:
+        stamp = d.stamp_base[file_name].get(taskflagname) or d.stamp[file_name]
+        extrainfo = d.stamp_extrainfo[file_name].get(taskflagname) or ""
+    else:
+        stamp = d.getVarFlag(taskflagname, 'stamp-base', True) or d.getVar('STAMP', True)
+        file_name = d.getVar('BB_FILENAME', True)
+        extrainfo = d.getVarFlag(taskflagname, 'stamp-extra-info', True) or ""
+
    if not stamp:
        return
-    stamp = "%s.%s" % (stamp, task)
-    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):
-        os.remove(stamp)
+
+    stamp = bb.parse.siggen.stampfile(stamp, file_name, taskname, extrainfo)
+
+    bb.utils.mkdirhier(os.path.dirname(stamp))
+
    return stamp

 def make_stamp(task, d, file_name = None):
@@ -326,16 +406,33 @@ def make_stamp(task, d, file_name = None):
    (d can be a data dict or dataCache)
    """
    stamp = stamp_internal(task, d, file_name)
+    # Remove the file and recreate to force timestamp
+    # change on broken NFS filesystems
    if stamp:
+        bb.utils.remove(stamp)
        f = open(stamp, "w")
        f.close()

+    # If we're in task context, write out a signature file for each task
+    # as it completes
+    if not task.endswith("_setscene") and task != "do_setscene" and not file_name:
+        file_name = d.getVar('BB_FILENAME', True)
+        bb.parse.siggen.dump_sigtask(file_name, task, d.getVar('STAMP', True), True)
+
 def del_stamp(task, d, file_name = None):
    """
    Removes a stamp for a given task
    (d can be a data dict or dataCache)
    """
-    stamp_internal(task, d, file_name)
+    stamp = stamp_internal(task, d, file_name)
+    bb.utils.remove(stamp)
+
+def stampfile(taskname, d, file_name = None):
+    """
+    Return the stamp for a given task
+    (d can be a data dict or dataCache)
+    """
+    return stamp_internal(taskname, d, file_name)

 def add_tasks(tasklist, d):
    task_deps = data.getVar('_task_deps', d)
@@ -353,7 +450,7 @@ def add_tasks(tasklist, d):
        if not task in task_deps['tasks']:
            task_deps['tasks'].append(task)

-        flags = data.getVarFlags(task, d)    
+        flags = data.getVarFlags(task, d)
        def getTask(name):
            if not name in task_deps:
                task_deps[name] = {}
@@ -365,6 +462,9 @@ def add_tasks(tasklist, d):
        getTask('rdeptask')
        getTask('recrdeptask')
        getTask('nostamp')
+        getTask('fakeroot')
+        getTask('noexec')
+        getTask('umask')
        task_deps['parents'][task] = []
        for dep in flags['deps']:
            dep = data.expand(dep, d)
@@ -379,4 +479,3 @@ def remove_task(task, kill, d):
       If kill is 1, also remove tasks that depend on this task."""

    data.delVarFlag(task, 'task', d)
-
--- a/bitbake/lib/bb/cache.py
+++ b/bitbake/lib/bb/cache.py
--- a/bitbake/lib/bb/cache_extra.py
+++ b/bitbake/lib/bb/cache_extra.py
@@ -0,0 +1,54 @@
+# ex:ts=4:sw=4:sts=4:et
+# -*- tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*-
+#
+# Extra RecipeInfo will be all defined in this file. Currently,
+# Only Hob (Image Creator) Requests some extra fields. So
+# HobRecipeInfo is defined. It's named HobRecipeInfo because it
+# is introduced by 'hob'. Users could also introduce other
+# RecipeInfo or simply use those already defined RecipeInfo.
+# In the following patch, this newly defined new extra RecipeInfo
+# will be dynamically loaded and used for loading/saving the extra
+# cache fields  
+
+# Copyright (C) 2011, Intel Corporation. All rights reserved.
+
+# 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 bb.cache import RecipeInfoCommon
+
+class HobRecipeInfo(RecipeInfoCommon):
+    __slots__ = ()
+
+    classname = "HobRecipeInfo"
+    # please override this member with the correct data cache file
+    # such as (bb_cache.dat, bb_extracache_hob.dat) 
+    cachefile = "bb_extracache_" + classname +".dat"        
+
+    def __init__(self, filename, metadata):
+
+        self.summary = self.getvar('SUMMARY', metadata)
+        self.license = self.getvar('LICENSE', metadata)
+        self.section = self.getvar('SECTION', metadata)
+
+    @classmethod
+    def init_cacheData(cls, cachedata):
+        # CacheData in Hob RecipeInfo Class
+        cachedata.summary = {}
+        cachedata.license = {}
+        cachedata.section = {}
+
+    def add_cacheData(self, cachedata, fn):
+        cachedata.summary[fn] = self.summary
+        cachedata.license[fn] = self.license
+        cachedata.section[fn] = self.section
--- a/bitbake/lib/bb/codeparser.py
+++ b/bitbake/lib/bb/codeparser.py
@@ -0,0 +1,375 @@
+import ast
+import codegen
+import logging
+import os.path
+import bb.utils, bb.data
+from itertools import chain
+from pysh import pyshyacc, pyshlex, sherrors
+
+
+logger = logging.getLogger('BitBake.CodeParser')
+PARSERCACHE_VERSION = 2
+
+try:
+    import cPickle as pickle
+except ImportError:
+    import pickle
+    logger.info('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", "\t", " "]:
+        i = i + 1
+
+    if i == 0:
+        return codestr
+
+    if codestr[i-1] == "\t" or codestr[i-1] == " ":
+        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")
+    logger.debug(1, "Using cache in '%s' for codeparser cache", cachefile)
+    return cachefile
+
+def parser_cache_init(d):
+    global pythonparsecache
+    global shellparsecache
+
+    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
+
+    pythonparsecache = data[0]
+    shellparsecache = data[1]
+
+def parser_cache_save(d):
+    cachefile = parser_cachefile(d)
+    if not cachefile:
+        return
+
+    glf = bb.utils.lockfile(cachefile + ".lock", shared=True)
+
+    i = os.getpid()
+    lf = None
+    while not lf:
+        shellcache = {}
+        pythoncache = {}
+
+        lf = bb.utils.lockfile(cachefile + ".lock." + str(i), retry=False)
+        if not lf or os.path.exists(cachefile + "-" + str(i)):
+            if lf:
+               bb.utils.unlockfile(lf) 
+               lf = None
+            i = i + 1
+            continue
+
+        try:
+            p = pickle.Unpickler(file(cachefile, "rb"))
+            data, version = p.load()
+        except (IOError, EOFError, ValueError):
+            data, version = None, None
+
+        if version != PARSERCACHE_VERSION:
+            shellcache = shellparsecache
+            pythoncache = pythonparsecache
+        else:
+            for h in pythonparsecache:
+                if h not in data[0]:
+                    pythoncache[h] = pythonparsecache[h]
+            for h in shellparsecache:
+                if h not in data[1]:
+                    shellcache[h] = shellparsecache[h]
+
+        p = pickle.Pickler(file(cachefile + "-" + str(i), "wb"), -1)
+        p.dump([[pythoncache, shellcache], PARSERCACHE_VERSION])
+
+    bb.utils.unlockfile(lf)
+    bb.utils.unlockfile(glf)
+
+def parser_cache_savemerge(d):
+    cachefile = parser_cachefile(d)
+    if not cachefile:
+        return
+
+    glf = bb.utils.lockfile(cachefile + ".lock")
+
+    try:
+        p = pickle.Unpickler(file(cachefile, "rb"))
+        data, version = p.load()
+    except (IOError, EOFError):
+        data, version = None, None
+
+    if version != PARSERCACHE_VERSION:
+        data = [{}, {}]
+
+    for f in [y for y in os.listdir(os.path.dirname(cachefile)) if y.startswith(os.path.basename(cachefile) + '-')]:
+        f = os.path.join(os.path.dirname(cachefile), f)
+        try:
+            p = pickle.Unpickler(file(f, "rb"))
+            extradata, version = p.load()
+        except (IOError, EOFError):
+            extradata, version = [{}, {}], None
+        
+        if version != PARSERCACHE_VERSION:
+            continue
+
+        for h in extradata[0]:
+            if h not in data[0]:
+                data[0][h] = extradata[0][h]
+        for h in extradata[1]:
+            if h not in data[1]:
+                data[1][h] = extradata[1][h]
+        os.unlink(f)
+
+    p = pickle.Pickler(file(cachefile, "wb"), -1)
+    p.dump([data, PARSERCACHE_VERSION])
+
+    bb.utils.unlockfile(glf)
+
+
+Logger = logging.getLoggerClass()
+class BufferedLogger(Logger):
+    def __init__(self, name, level=0, target=None):
+        Logger.__init__(self, name)
+        self.setLevel(level)
+        self.buffer = []
+        self.target = target
+
+    def handle(self, record):
+        self.buffer.append(record)
+
+    def flush(self):
+        for record in self.buffer:
+            self.target.handle(record)
+        self.buffer = []
+
+class PythonParser():
+    getvars = ("d.getVar", "bb.data.getVar", "data.getVar")
+    execfuncs = ("bb.build.exec_func", "bb.build.exec_task")
+
+    def warn(self, 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:
+            self.log.debug(2, 'Failed to convert function and argument to source form')
+        else:
+            self.log.debug(1, self.unhandled_message % (funcstr, argstr))
+
+    def visit_Call(self, node):
+        name = self.called_node_name(node.func)
+        if name in self.getvars:
+            if isinstance(node.args[0], ast.Str):
+                self.var_references.add(node.args[0].s)
+            else:
+                self.warn(node.func, node.args[0])
+        elif name in self.execfuncs:
+            if isinstance(node.args[0], ast.Str):
+                self.var_execs.add(node.args[0].s)
+            else:
+                self.warn(node.func, node.args[0])
+        elif name and isinstance(node.func, (ast.Name, ast.Attribute)):
+            self.execs.add(name)
+
+    def called_node_name(self, node):
+        """Given a called node, return its original string form"""
+        components = []
+        while node:
+            if isinstance(node, ast.Attribute):
+                components.append(node.attr)
+                node = node.value
+            elif isinstance(node, ast.Name):
+                components.append(node.id)
+                return '.'.join(reversed(components))
+            else:
+                break
+
+    def __init__(self, name, log):
+        self.var_references = set()
+        self.var_execs = set()
+        self.execs = set()
+        self.references = set()
+        self.log = BufferedLogger('BitBake.Data.%s' % name, logging.DEBUG, log)
+
+        self.unhandled_message = "in call of %s, argument '%s' is not a string literal"
+        self.unhandled_message = "while parsing %s, %s" % (name, self.unhandled_message)
+
+    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)
+
+        for n in ast.walk(code):
+            if n.__class__.__name__ == "Call":
+                self.visit_Call(n)
+
+        self.references.update(self.var_references)
+        self.references.update(self.var_execs)
+
+        pythonparsecache[h] = {}
+        pythonparsecache[h]["refs"] = self.references
+        pythonparsecache[h]["execs"] = self.execs
+
+class ShellParser():
+    def __init__(self, name, log):
+        self.funcdefs = set()
+        self.allexecs = set()
+        self.execs = set()
+        self.log = BufferedLogger('BitBake.Data.%s' % name, logging.DEBUG, log)
+        self.unhandled_template = "unable to handle non-literal command '%s'"
+        self.unhandled_template = "while parsing %s, %s" % (name, self.unhandled_template)
+
+    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 sherrors.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("$"):
+                    self.log.debug(1, self.unhandled_template % 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,337 @@
+"""
+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 CommandCompleted(bb.event.Event):
+    pass
+
+class CommandExit(bb.event.Event):
+    def  __init__(self, exitcode):
+        bb.event.Event.__init__(self)
+        self.exitcode = int(exitcode)
+
+class CommandFailed(CommandExit):
+    def __init__(self, message):
+        self.error = message
+        CommandExit.__init__(self, 1)
+
+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_registration_cb(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.state in
+                    (bb.cooker.state.initial, bb.cooker.state.parsing)):
+                    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, msg=None, code=None):
+        if msg:
+            bb.event.fire(CommandFailed(msg), self.cooker.configuration.event_data)
+        elif code:
+            bb.event.fire(CommandExit(code), self.cooker.configuration.event_data)
+        else:
+            bb.event.fire(CommandCompleted(), 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.shutdown()
+
+    def stateStop(self, command, params):
+        """
+        Stop the cooker
+        """
+        command.cooker.stop()
+
+    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)
+
+    def resetCooker(self, command, params):
+        """
+        Reset the cooker to its initial state, thus forcing a reparse for
+        any async command that has the needcache property set to True
+        """
+        command.cooker.reset()
+
+
+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 generateTargetsTree(self, command, params):
+        """
+        Generate a tree of buildable targets.
+        If klass is provided ensure all recipes that inherit the class are
+        included in the package list.
+        If pkg_list provided use that list (plus any extras brought in by
+        klass) rather than generating a tree for all packages.
+        """
+        klass = params[0]
+        if len(params) > 1:
+            pkg_list = params[1]
+        else:
+            pkg_list = []
+
+        command.cooker.generateTargetsTree(klass, pkg_list)
+        command.finishAsyncCommand()
+    generateTargetsTree.needcache = True
+
+    def findConfigFiles(self, command, params):
+        """
+        Find config files which provide appropriate values
+        for the passed configuration variable. i.e. MACHINE
+        """
+        varname = params[0]
+
+        command.cooker.findConfigFiles(varname)
+        command.finishAsyncCommand()
+    findConfigFiles.needcache = True
+
+    def findFilesMatchingInDir(self, command, params):
+        """
+        Find implementation files matching the specified pattern
+        in the requested subdirectory of a BBPATH
+        """
+        pattern = params[0]
+        directory = params[1]
+
+        command.cooker.findFilesMatchingInDir(pattern, directory)
+        command.finishAsyncCommand()
+    findFilesMatchingInDir.needcache = True
+
+    def findConfigFilePath(self, command, params):
+        """
+        Find the path of the requested configuration file
+        """
+        configfile = params[0]
+
+        command.cooker.findConfigFilePath(configfile)
+        command.finishAsyncCommand()
+    findConfigFilePath.needcache = False
+
+    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 reparseFiles(self, command, params):
+        """
+        Reparse .bb files
+        """
+        command.cooker.reparseFiles()
+        command.finishAsyncCommand()
+    reparseFiles.needcache = True
+
+    def compareRevisions(self, command, params):
+        """
+        Parse the .bb files
+        """
+        if bb.fetch.fetcher_compare_revisions(command.cooker.configuration.data):
+            command.finishAsyncCommand(code=1)
+        else:
+            command.finishAsyncCommand()
+    compareRevisions.needcache = True
--- a/bitbake/lib/bb/compat.py
+++ b/bitbake/lib/bb/compat.py
@@ -0,0 +1,28 @@
+"""Code pulled from future python versions, here for compatibility"""
+
+def total_ordering(cls):
+    """Class decorator that fills in missing ordering methods"""
+    convert = {
+        '__lt__': [('__gt__', lambda self, other: other < self),
+                   ('__le__', lambda self, other: not other < self),
+                   ('__ge__', lambda self, other: not self < other)],
+        '__le__': [('__ge__', lambda self, other: other <= self),
+                   ('__lt__', lambda self, other: not other <= self),
+                   ('__gt__', lambda self, other: not self <= other)],
+        '__gt__': [('__lt__', lambda self, other: other > self),
+                   ('__ge__', lambda self, other: not other > self),
+                   ('__le__', lambda self, other: not self > other)],
+        '__ge__': [('__le__', lambda self, other: other >= self),
+                   ('__gt__', lambda self, other: not other >= self),
+                   ('__lt__', lambda self, other: not self >= other)]
+    }
+    roots = set(dir(cls)) & set(convert)
+    if not roots:
+        raise ValueError('must define at least one ordering operation: < > <= >=')
+    root = max(roots)       # prefer __lt__ to __le__ to __gt__ to __ge__
+    for opname, opfunc in convert[root]:
+        if opname not in roots:
+            opfunc.__name__ = opname
+            opfunc.__doc__ = getattr(int, opname).__doc__
+            setattr(cls, opname, opfunc)
+    return cls
--- 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,42 @@ 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

+logger = data_smart.logger
 _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,91 +80,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
-
-    Example:
-        >>> d = init()
-        >>> setVar('TEST', 'testcontents', d)
-        >>> print getVar('TEST', d)
-        testcontents
-    """
-    return d.getVar(var,exp)
+    """Gets the value of a variable"""
+    return d.getVar(var, exp)


 def renameVar(key, newkey, d):
-    """Renames a variable from key to newkey
-
-    Example:
-        >>> d = init()
-        >>> setVar('TEST', 'testcontents', d)
-        >>> renameVar('TEST', 'TEST2', d)
-        >>> print getVar('TEST2', d)
-        testcontents
-    """
+    """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
@@ -167,115 +116,27 @@ 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):
@@ -292,46 +153,24 @@ def expandKeys(alterdata, readdata = None):
            continue
        todolist[key] = ekey

-    # These two for loops are split for performance to maximise the 
+    # These two for loops are split for performance to maximise the
    # usefulness of the expand cache

    for key in todolist:
        ekey = todolist[key]
        renameVar(key, ekey, 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)
-
-def inheritFromOS(d):
-    """Inherit variables from the environment."""
-    for s in os.environ.keys():
-        try:
-            setVar(s, os.environ[s], d)
-            setVarFlag(s, "export", True, d)
-        except TypeError:
-            pass
+def inheritFromOS(d, savedenv, permitted):
+    """Inherit variables from the initial environment."""
+    exportlist = bb.utils.preserved_envvars_exported()
+    for s in savedenv.keys():
+        if s in permitted:
+            try:
+                setVar(s, getVar(s, savedenv, True), d)
+                if s in exportlist:
+                    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."""
@@ -348,20 +187,15 @@ def emit_var(var, o=sys.__stdout__, d = init(), all=False):
        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 as 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
+        commentVal = re.sub('\n', '\n#', str(oval))
+        o.write('# %s=%s\n' % (var, commentVal))

    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
@@ -370,12 +204,13 @@ def emit_var(var, o=sys.__stdout__, d = init(), all=False):

    if unexport:
        o.write('unset %s\n' % varExpanded)
-        return 1
+        return 0

-    val.rstrip()
    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))
@@ -387,176 +222,122 @@ def emit_var(var, o=sys.__stdout__, d = init(), all=False):
    # 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())
+    alter = re.sub('\n', ' \\\n', alter)
    o.write('%s="%s"\n' % (varExpanded, alter))
-    return 1
-
+    return 0

 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 exported_keys(d):
+    return (key for key in d.keys() if not key.startswith('__') and
+                                      d.getVarFlag(key, 'export') and
+                                      not d.getVarFlag(key, 'unexport'))

-    for e in env:
-        if not getVarFlag(e, "func", d):
-            continue
-        emit_var(e, o, d) and o.write('\n')
+def exported_vars(d):
+    for key in exported_keys(d):
+        try:
+            value = d.getVar(key, True)
+        except Exception:
+            pass
+
+        if value is not None:
+            yield key, str(value)
+
+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(func, logger).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(dep, logger).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, vardepvals, d):
+    deps = set()
+    vardeps = d.getVarFlag(key, "vardeps", True)
+    try:
+        value = d.getVar(key, False)
+        if key in vardepvals:
+           value =  d.getVarFlag(key, "vardepvalue", True)
+        elif d.getVarFlag(key, "func"):
+            if d.getVarFlag(key, "python"):
+                parsedvar = d.expandWithRefs(value, key)
+                parser = bb.codeparser.PythonParser(key, logger)
+                parser.parse_python(parsedvar.value)
+                deps = deps | parser.references
+            else:
+                parsedvar = d.expandWithRefs(value, key)
+                parser = bb.codeparser.ShellParser(key, logger)
+                parser.parse_shell(parsedvar.value)
+                deps = deps | shelldeps
+            if vardeps is None:
+                parser.log.flush()
+            deps = deps | parsedvar.references
+            deps = deps | (keys & parser.execs) | (keys & parsedvar.execs)
+        else:
+            parser = d.expandWithRefs(value, key)
+            deps |= parser.references
+            deps = deps | (keys & parser.execs)
+        deps |= set((vardeps or "").split())
+        deps -= set((d.getVarFlag(key, "vardepsexclude", True) or "").split())
+    except:
+        bb.note("Error expanding variable %s" % key)
+        raise
+    return deps, value
+    #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"))
+    vardepvals = set(key for key in keys if d.getVarFlag(key, "vardepvalue"))

-        >>> setVar('OVERRIDES', 'arm:ramses:local', d)
-        >>> setVar('TEST', 'original', d)
-        >>> update_data(d)
-        >>> print getVar('TEST', d)
-        local
-
-        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)
+    deps = {}
+    values = {}

+    tasklist = bb.data.getVar('__BBTASKS', d) or []
+    for task in tasklist:
+        deps[task], values[task] = build_dependencies(task, keys, shelldeps, vardepvals, 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], values[dep] = build_dependencies(dep, keys, shelldeps, vardepvals, d)
+                newdeps |=  deps[dep]
+            newdeps -= seen
+        #print "For %s: %s" % (task, str(taskdeps[task]))
+    return tasklist, deps, values

 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
-    import bb
-    from bb import data
-    bb.msg.set_debug_level(0)
-    doctest.testmod(data)
-
-if __name__ == "__main__":
-    _test()
--- a/bitbake/lib/bb/data_smart.py
+++ b/bitbake/lib/bb/data_smart.py
@@ -28,20 +28,86 @@ 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 bb
-from bb   import utils, methodpool
-from COW  import COWDictBase
-from new  import classobj
+import copy, re
+from collections import MutableMapping
+import logging
+import bb, bb.codeparser
+from bb   import utils
+from bb.COW  import COWDictBase

+logger = logging.getLogger("BitBake.Data")

-__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 DataSmart:
+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(self.varname, logger)
+            parser.parse_python(code)
+            if self.varname:
+                vardeps = self.d.getVarFlag(self.varname, "vardeps", True)
+                if vardeps is None:
+                    parser.log.flush()
+            else:
+                parser.log.flush()
+            self.references |= parser.references
+            self.execs |= parser.execs
+
+            value = utils.better_eval(codeobj, DataContext(self.d))
+            return str(value)
+
+
+class DataContext(dict):
+    def __init__(self, metadata, **kwargs):
+        self.metadata = metadata
+        dict.__init__(self, **kwargs)
+        self['d'] = metadata
+
+    def __missing__(self, key):
+        value = self.metadata.getVar(key, True)
+        if value is None or self.metadata.getVarFlag(key, 'func'):
+            raise KeyError(key)
+        else:
+            return value
+
+class ExpansionError(Exception):
+    def __init__(self, varname, expression, exception):
+        self.expression = expression
+        self.variablename = varname
+        self.exception = exception
+        self.msg = "Failure expanding variable %s, expression was %s which triggered exception %s: %s" % (varname, expression, type(exception).__name__, exception)
+        Exception.__init__(self, self.msg)
+        self.args = (varname, expression, exception)
+    def __str__(self):
+        return self.msg
+
+class DataSmart(MutableMapping):
    def __init__(self, special = COWDictBase.copy(), seen = COWDictBase.copy() ):
        self.dict = {}

@@ -51,68 +117,115 @@ 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))
-            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))
+                s = __expand_var_regexp__.sub(varparse.var_sub, s)
+                s = __expand_python_regexp__.sub(varparse.python_sub, s)
+                if s == olds:
+                    break
+            except ExpansionError:
                raise
+            except Exception as exc:
+                raise ExpansionError(varname, s, exc)
+
+        varparse.value = s

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

-        return s
+        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].copy()
+            for var in vars:
+                name = var[:-l]
+                try:
+                    self.setVar(name, self.getVar(var, False))
+                    self.delVar(var)
+                except Exception:
+                    logger.info("Untracked delVar")
+
+        # now on to the appends and prepends
+        for op in __setvar_keyword__:
+            if op in self._special_values:
+                appends = self._special_values[op] or []
+                for append in appends:
+                    keep = []
+                    for (a, o) in self.getVarFlag(append, op) or []:
+                        if o and not o in overrides:
+                            keep.append((a ,o))
+                            continue
+
+                        if op == "_append":
+                            sval = self.getVar(append, False) or ""
+                            sval += a
+                            self.setVar(append, sval)
+                        elif op == "_prepend":
+                            sval = a + (self.getVar(append, False) or "")
+                            self.setVar(append, sval)
+
+                    # We save overrides that may be applied at some later stage
+                    if keep:
+                        self.setVarFlag(append, op, keep)
+                    else:
+                        self.delVarFlag(append, op)

    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:
@@ -125,7 +238,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__:
@@ -140,7 +253,7 @@ class DataSmart:
            # pay the cookie monster
            try:
                self._special_values[keyword].add( base )
-            except:
+            except KeyError:
                self._special_values[keyword] = set()
                self._special_values[keyword].add( base )

@@ -152,23 +265,25 @@ class DataSmart:
        # 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()
-            self._seen_overrides[override].add( var )
+            if len(override) > 0:
+                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, expand=False, noweakdefault=False):
+        value = self.getVarFlag(var, "content", False, noweakdefault)

-        if exp and value:
-            return self.expand(value,var)
+        # Call expand() separately to make use of the expand cache
+        if expand and value:
+            return self.expand(value, var)
        return value

    def renameVar(self, key, newkey):
        """
-        Rename the variable key to newkey 
+        Rename the variable key to newkey
        """
        val = self.getVar(key, 0)
        if val is not None:
@@ -182,30 +297,39 @@ class DataSmart:
            dest = self.getVarFlag(newkey, i) or []
            dest.extend(src)
            self.setVarFlag(newkey, i, dest)
-            
-            if self._special_values.has_key(i) and key in self._special_values[i]:
+
+            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):
+    def delVar(self, var):
        self.expand_cache = {}
        self.dict[var] = {}
+        if '_' in var:
+            override = var[var.rfind('_')+1:]
+            if override and override in self._seen_overrides and var in self._seen_overrides[override]:
+                self._seen_overrides[override].remove(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, expand=False, noweakdefault=False):
        local_var = self._findVar(var)
+        value = None
        if local_var:
            if flag in local_var:
-                return copy.copy(local_var[flag])
-        return None
+                value = copy.copy(local_var[flag])
+            elif flag == "content" and "defaultval" in local_var and not noweakdefault:
+                value = copy.copy(local_var["defaultval"])
+        if expand and value:
+            value = self.expand(value, None)
+        return value

-    def delVarFlag(self,var,flag):
+    def delVarFlag(self, var, flag):
        local_var = self._findVar(var)
        if not local_var:
            return
@@ -215,21 +339,21 @@ 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 local_var.keys():
+            for i in local_var:
                if i == "content":
                    continue
                flags[i] = local_var[i]
@@ -239,7 +363,7 @@ class DataSmart:
        return flags


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

@@ -265,25 +389,57 @@ class DataSmart:

        return data

-    # Dictionary Methods
-    def keys(self):
-        def _keys(d, mykey):
+    def expandVarref(self, variable, parents=False):
+        """Find all references to variable in the data and expand it
+           in place, optionally descending to parent datastores."""
+
+        if parents:
+            keys = iter(self)
+        else:
+            keys = self.localkeys()
+
+        ref = '${%s}' % variable
+        value = self.getVar(variable, False)
+        for key in keys:
+            referrervalue = self.getVar(key, False)
+            if referrervalue and ref in referrervalue:
+                self.setVar(key, referrervalue.replace(ref, value))
+
+    def localkeys(self):
+        for key in self.dict:
+            if key != '_data':
+                yield key
+
+    def __iter__(self):
+        def keylist(d):        
+            klist = set()
+            for key in d:
+                if key == "_data":
+                    continue
+                if not d[key]:
+                    continue
+                klist.add(key)
+
            if "_data" in d:
-                _keys(d["_data"],mykey)
+                klist |= keylist(d["_data"])

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

-    def __getitem__(self,item):
-        #print "Warning deprecated"
-        return self.getVar(item, False)
+        for k in keylist(self.dict):
+             yield k

-    def __setitem__(self,var,data):
-        #print "Warning deprecated"
-        self.setVar(var,data)
+    def __len__(self):
+        return len(frozenset(self))

+    def __getitem__(self, item):
+        value = self.getVar(item, False)
+        if value is None:
+            raise KeyError(item)
+        else:
+            return value

+    def __setitem__(self, var, value):
+        self.setVar(var, value)
+
+    def __delitem__(self, var):
+        self.delVar(var)
--- a/bitbake/lib/bb/event.py
+++ b/bitbake/lib/bb/event.py
@@ -22,100 +22,180 @@ 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
+try:
+    import cPickle as pickle
+except ImportError:
+    import pickle
+import logging
+import atexit
+import traceback
 import bb.utils

-class Event:
+# 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
+
+logger = logging.getLogger('BitBake.Event')
+
+class Event(object):
    """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 execute_handler(name, handler, event, d):
+    event.data = d
+    try:
+        ret = handler(event)
+    except bb.parse.SkipPackage:
+        raise
+    except Exception:
+        etype, value, tb = sys.exc_info()
+        logger.error("Execution of event handler '%s' failed" % name,
+                        exc_info=(etype, value, tb.tb_next))
+        raise
+    except SystemExit as exc:
+        if exc.code != 0:
+            logger.error("Execution of event handler '%s' failed" % name)
+        raise
+    finally:
+        del event.data

-def fire(event):
+    if ret is not None:
+        warnings.warn("Using Handled/NotHandled in event handlers is deprecated",
+                        DeprecationWarning, stacklevel = 2)
+
+def fire_class_handlers(event, d):
+    if isinstance(event, logging.LogRecord):
+        return
+
+    for name, handler in _handlers.iteritems():
+        try:
+            execute_handler(name, handler, event, d)
+        except Exception:
+            continue
+
+ui_queue = []
+@atexit.register
+def print_ui_queue():
+    """If we're exiting before a UI has been spawned, display any queued
+    LogRecords to the console."""
+    logger = logging.getLogger("BitBake")
+    if not _ui_handlers:
+        from bb.msg import BBLogFormatter
+        console = logging.StreamHandler(sys.stdout)
+        console.setFormatter(BBLogFormatter("%(levelname)s: %(message)s"))
+        logger.handlers = [console]
+        for event in ui_queue:
+            if isinstance(event, logging.LogRecord):
+                logger.handle(event)
+
+def fire_ui_handlers(event, d):
+    if not _ui_handlers:
+        # No UI handlers registered yet, queue up the messages
+        ui_queue.append(event)
+        return
+
+    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.
+             if hasattr(_ui_handlers[h].event, "sendpickle"):
+                _ui_handlers[h].event.sendpickle((pickle.dumps(event)))
+             else:
+                _ui_handlers[h].event.send(event)
+        except:
+            errors.append(h)
+    for h in errors:
+        del _ui_handlers[h]
+
+def fire(event, d):
    """Fire off an Event"""
-    for h in _handlers:
-        if type(h).__name__ == "code":
-            exec(h)
-            if tmpHandler(event) == Handled:
-                return Handled
-        else:
-            if h(event) == Handled:
-                return Handled
-    return NotHandled

+    # 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)
+
+def fire_from_worker(event, d):
+    if not event.startswith("<event>") or not event.endswith("</event>"):
+        print("Error, not an event %s" % event)
+        return
+    event = pickle.loads(event[7:-8])
+    fire_ui_handlers(event, d)
+
+noop = lambda _: None
 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
-        if type(handler).__name__ == "str":
-            _registerCode(handler)
+        # handle string containing python code
+        if isinstance(handler, basestring):
+            tmp = "def %s(e):\n%s" % (name, handler)
+            try:
+                code = compile(tmp, "%s(e)" % name, "exec")
+            except SyntaxError:
+                logger.error("Unable to register event handler '%s':\n%s", name,
+                             ''.join(traceback.format_exc(limit=0)))
+                _handlers[name] = noop
+                return
+            env = {}
+            bb.utils.simple_exec(code, env)
+            func = bb.utils.better_eval(name, env)
+            _handlers[name] = func
        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
+    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"""
@@ -127,13 +207,24 @@ def getName(e):
 class ConfigParsed(Event):
    """Configuration Parsing Complete"""

+class RecipeEvent(Event):
+    def __init__(self, fn):
+        self.fn = fn
+        Event.__init__(self)
+
+class RecipePreFinalise(RecipeEvent):
+    """ Recipe Parsing Complete but not yet finialised"""
+
+class RecipeParsed(RecipeEvent):
+    """ Recipe Parsing Complete """
+
 class StampUpdate(Event):
    """Trigger for any adjustment of the stamp files to happen"""

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

    def getStampPrefix(self):
        return self._stampfns
@@ -144,29 +235,13 @@ class StampUpdate(Event):
    stampPrefix = property(getStampPrefix)
    targets = property(getTargets)

-class PkgBase(Event):
-    """Base class for package events"""
-
-    def __init__(self, t, d):
-        self._pkg = t
-        Event.__init__(self, d)
-
-    def getPkg(self):
-        return self._pkg
-
-    def setPkg(self, pkg):
-        self._pkg = pkg
-
-    pkg = property(getPkg, setPkg, None, "pkg property")
-
-
 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):
@@ -198,32 +273,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):
@@ -234,20 +284,17 @@ 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, reasons=[]):
+        Event.__init__(self)
        self._item = item
        self._runtime = runtime
+        self._dependees = dependees
+        self._reasons = reasons

    def getItem(self):
        return self._item
@@ -258,8 +305,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
@@ -281,3 +328,134 @@ class MultipleProviders(Event):
        Get the possible Candidates for a PROVIDER.
        """
        return self._candidates
+
+class ParseStarted(Event):
+    """Recipe parsing for the runqueue has begun"""
+    def __init__(self, total):
+        Event.__init__(self)
+        self.total = total
+
+class ParseCompleted(Event):
+    """Recipe parsing for the runqueue has completed"""
+
+    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 ParseProgress(Event):
+    """Recipe parsing progress"""
+
+    def __init__(self, current):
+        self.current = current
+
+class CacheLoadStarted(Event):
+    """Loading of the dependency cache has begun"""
+    def __init__(self, total):
+        Event.__init__(self)
+        self.total = total
+
+class CacheLoadProgress(Event):
+    """Cache loading progress"""
+    def __init__(self, current):
+        Event.__init__(self)
+        self.current = current
+
+class CacheLoadCompleted(Event):
+    """Cache loading is complete"""
+    def __init__(self, total, num_entries):
+        Event.__init__(self)
+        self.total = total
+        self.num_entries = num_entries
+
+
+class DepTreeGenerated(Event):
+    """
+    Event when a dependency tree has been generated
+    """
+
+    def __init__(self, depgraph):
+        Event.__init__(self)
+        self._depgraph = depgraph
+
+class TargetsTreeGenerated(Event):
+    """
+    Event when a set of buildable targets has been generated
+    """
+    def __init__(self, model):
+        Event.__init__(self)
+        self._model = model
+
+class FilesMatchingFound(Event):
+    """
+    Event when a list of files matching the supplied pattern has
+    been generated
+    """
+    def __init__(self, pattern, matches):
+        Event.__init__(self)
+        self._pattern = pattern
+        self._matches = matches
+
+class ConfigFilesFound(Event):
+    """
+    Event when a list of appropriate config files has been generated
+    """
+    def __init__(self, variable, values):
+        Event.__init__(self)
+        self._variable = variable
+        self._values = values
+
+class ConfigFilePathFound(Event):
+    """
+    Event when a path for a config file has been found
+    """
+    def __init__(self, path):
+        Event.__init__(self)
+        self._path = path
+
+class MsgBase(Event):
+    """Base class for messages"""
+
+    def __init__(self, msg):
+        self._message = msg
+        Event.__init__(self)
+
+class MsgDebug(MsgBase):
+    """Debug Message"""
+
+class MsgNote(MsgBase):
+    """Note Message"""
+
+class MsgWarn(MsgBase):
+    """Warning Message"""
+
+class MsgError(MsgBase):
+    """Error Message"""
+
+class MsgFatal(MsgBase):
+    """Fatal Message"""
+
+class MsgPlain(MsgBase):
+    """General output"""
+
+class LogHandler(logging.Handler):
+    """Dispatch logging messages as bitbake events"""
+
+    def emit(self, record):
+        if record.exc_info:
+            etype, value, tb = record.exc_info
+            if hasattr(tb, 'tb_next'):
+                tb = list(bb.exceptions.extract_traceback(tb, context=3))
+            record.bb_exc_info = (etype, value, tb)
+            record.exc_info = None
+        fire(record, None)
+
+    def filter(self, record):
+        record.taskpid = worker_pid
+        return True
--- a/bitbake/lib/bb/exceptions.py
+++ b/bitbake/lib/bb/exceptions.py
@@ -0,0 +1,84 @@
+from __future__ import absolute_import
+import inspect
+import traceback
+import bb.namedtuple_with_abc
+from collections import namedtuple
+
+
+class TracebackEntry(namedtuple.abc):
+    """Pickleable representation of a traceback entry"""
+    _fields = 'filename lineno function args code_context index'
+    _header = '  File "{0.filename}", line {0.lineno}, in {0.function}{0.args}'
+
+    def format(self, formatter=None):
+        if not self.code_context:
+            return self._header.format(self) + '\n'
+
+        formatted = [self._header.format(self) + ':\n']
+
+        for lineindex, line in enumerate(self.code_context):
+            if formatter:
+                line = formatter(line)
+
+            if lineindex == self.index:
+                formatted.append('    >%s' % line)
+            else:
+                formatted.append('     %s' % line)
+        return formatted
+
+    def __str__(self):
+        return ''.join(self.format())
+
+def _get_frame_args(frame):
+    """Get the formatted arguments and class (if available) for a frame"""
+    arginfo = inspect.getargvalues(frame)
+    if not arginfo.args:
+        return '', None
+
+    firstarg = arginfo.args[0]
+    if firstarg == 'self':
+        self = arginfo.locals['self']
+        cls = self.__class__.__name__
+
+        arginfo.args.pop(0)
+        del arginfo.locals['self']
+    else:
+        cls = None
+
+    formatted = inspect.formatargvalues(*arginfo)
+    return formatted, cls
+
+def extract_traceback(tb, context=1):
+    frames = inspect.getinnerframes(tb, context)
+    for frame, filename, lineno, function, code_context, index in frames:
+        formatted_args, cls = _get_frame_args(frame)
+        if cls:
+            function = '%s.%s' % (cls, function)
+        yield TracebackEntry(filename, lineno, function, formatted_args,
+                             code_context, index)
+
+def format_extracted(extracted, formatter=None, limit=None):
+    if limit:
+        extracted = extracted[-limit:]
+
+    formatted = []
+    for tracebackinfo in extracted:
+        formatted.extend(tracebackinfo.format(formatter))
+    return formatted
+
+
+def format_exception(etype, value, tb, context=1, limit=None, formatter=None):
+    formatted = ['Traceback (most recent call last):\n']
+
+    if hasattr(tb, 'tb_next'):
+        tb = extract_traceback(tb, context)
+
+    formatted.extend(format_extracted(tb, formatter, limit))
+    formatted.extend(traceback.format_exception_only(etype, value))
+    return formatted
+
+def to_string(exc):
+    if isinstance(exc, SystemExit):
+        if not isinstance(exc.code, basestring):
+            return 'Exited with "%d"' % exc.code
+    return str(exc)
--- a/bitbake/lib/bb/fetch/init.py
+++ b/bitbake/lib/bb/fetch/init.py
@@ -24,15 +24,21 @@ BitBake build tools.
 #
 # Based on functions from the base bb module, Copyright 2003 Holger Schurig

-import os, re, fcntl
+from __future__ import absolute_import
+from __future__ import print_function
+import os, re
+import logging
 import bb
 from   bb import data
 from   bb import persist_data
+from   bb import utils

-try:
-    import cPickle as pickle
-except ImportError:
-    import pickle
+__version__ = "1"
+
+logger = logging.getLogger("BitBake.Fetch")
+
+class MalformedUrl(Exception):
+    """Exception raised when encountering an invalid url"""

 class FetchError(Exception):
    """Exception raised when a download fails"""
@@ -52,35 +58,91 @@ class MD5SumError(Exception):
 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 = ['','','','','',{}]
+        logger.debug(1, "uri_replace: passed an undefined value, not replacing")
+    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:
                    if d:
                        localfn = bb.fetch.localpath(uri, d)
                        if localfn:
-                            result_decoded[loc] = os.path.dirname(result_decoded[loc]) + "/" + os.path.basename(bb.fetch.localpath(uri, d))
-#                       bb.msg.note(1, bb.msg.domain.Fetcher, "uri_replace: matching %s against %s and replacing with %s" % (i, uri_decoded[loc], uri_replace_decoded[loc]))
+                            result_decoded[loc] = os.path.join(os.path.dirname(result_decoded[loc]), os.path.basename(bb.fetch.localpath(uri, d)))
            else:
-#               bb.msg.note(1, bb.msg.domain.Fetcher, "uri_replace: no match")
                return uri
-#           else:
-#               for j in i.keys():
-#                   FIXME: apply replacements against options
-    return bb.encodeurl(result_decoded)
+    return encodeurl(result_decoded)

 methods = []
 urldata_cache = {}
@@ -88,45 +150,45 @@ saved_headrevs = {}

 def fetcher_init(d):
    """
-    Called to initilize the fetchers once the configuration data is known
+    Called to initialize the fetchers once the configuration data is known.
    Calls before this must not hit the cache.
    """
-    pd = persist_data.PersistData(d)
-    # When to drop SCM head revisions controled by user policy
+    # 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)
+        logger.debug(1, "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)
+        logger.debug(1, "Clearing SRCREV cache due to cache policy of: %s", srcrev_policy)
+        revs = persist_data.persist('BB_URI_HEADREVS', d)
        try:
-            bb.fetch.saved_headrevs = pd.getKeyValues("BB_URI_HEADREVS")
+            bb.fetch.saved_headrevs = revs.items()
        except:
            pass
-        pd.delDomain("BB_URI_HEADREVS")
+        revs.clear()
    else:
-        bb.msg.fatal(bb.msg.domain.Fetcher, "Invalid SRCREV cache policy of: %s" % srcrev_policy)
-    # Make sure our domains exist
-    pd.addDomain("BB_URI_HEADREVS")
-    pd.addDomain("BB_URI_LOCALCOUNT")
+        raise FetchError("Invalid SRCREV cache policy of: %s" % srcrev_policy)

-def fetcher_compare_revisons(d):
+    for m in methods:
+        if hasattr(m, "init"):
+            m.init(d)
+
+def fetcher_compare_revisions(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)
-    data = pd.getKeyValues("BB_URI_HEADREVS")
+    data = persist_data.persist('BB_URI_HEADREVS', d).items()
    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)
+            logger.debug(1, "%s changed", key)
            changed = True
            return True
        else:
-            bb.msg.debug(2, bb.msg.domain.Fetcher, "%s did not change" % key)
+            logger.debug(2, "%s did not change", key)
    return False

 # Function call order is usually:
@@ -137,6 +199,7 @@ def fetcher_compare_revisons(d):

 def init(urls, d, setup = True):
    urldata = {}
+
    fn = bb.data.getVar('FILE', d, 1)
    if fn in urldata_cache:
        urldata = urldata_cache[fn]
@@ -148,11 +211,50 @@ def init(urls, d, setup = True):
    if setup:
        for url in urldata:
            if not urldata[url].setup:
-                urldata[url].setup_localpath(d) 
+                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 verify_checksum(u, ud, d):
+    """
+    verify the MD5 and SHA256 checksum for downloaded src
+
+    return value:
+        - True: checksum matched
+        - False: checksum unmatched
+
+    if checksum is missing in recipes file, "BB_STRICT_CHECKSUM" decide the return value.
+    if BB_STRICT_CHECKSUM = "1" then return false as unmatched, otherwise return true as
+    matched
+    """
+
+    if not ud.type in ["http", "https", "ftp", "ftps"]:
+        return
+
+    md5data = bb.utils.md5_file(ud.localpath)
+    sha256data = bb.utils.sha256_file(ud.localpath)
+
+    if (ud.md5_expected == None or ud.sha256_expected == None):
+        logger.warn('Missing SRC_URI checksum for %s, consider adding to the recipe:\n'
+                    'SRC_URI[%s] = "%s"\nSRC_URI[%s] = "%s"',
+                    ud.localpath, ud.md5_name, md5data,
+                    ud.sha256_name, sha256data)
+        if bb.data.getVar("BB_STRICT_CHECKSUM", d, True) == "1":
+            raise FetchError("No checksum specified for %s." % u)
+        return
+
+    if (ud.md5_expected != md5data or ud.sha256_expected != sha256data):
+        logger.error('The checksums for "%s" did not match.\n'
+                     '  MD5: expected "%s", got "%s"\n'
+                     '  SHA256: expected "%s", got "%s"\n',
+                     ud.localpath, ud.md5_expected, md5data,
+                     ud.sha256_expected, sha256data)
+        raise FetchError("%s checksum mismatch." % u)
+
 def go(d, urls = None):
    """
    Fetch all urls
@@ -165,48 +267,79 @@ def go(d, urls = None):
    for u in urls:
        ud = urldata[u]
        m = ud.method
-        if ud.localfile:
-            if not m.forcefetch(u, ud, d) and os.path.exists(ud.md5):
-                # File already present along with md5 stamp file
-                # Touch md5 file to show activity
-                try:
-                    os.utime(ud.md5, None)
-                except:
-                    # Errors aren't fatal here
-                    pass
-                continue
-            lf = bb.utils.lockfile(ud.lockfile)
-            if not m.forcefetch(u, ud, d) and os.path.exists(ud.md5):
-                # If someone else fetched this before we got the lock, 
-                # notice and don't try again
-                try:
-                    os.utime(ud.md5, None)
-                except:
-                    # Errors aren't fatal here
-                    pass
-                bb.utils.unlockfile(lf)
-                continue
-        m.go(u, ud, d)
-        if ud.localfile:
-            if not m.forcefetch(u, ud, d):
-                Fetch.write_md5sum(u, ud, d)
-            bb.utils.unlockfile(lf)
+        localpath = ""

+        if not ud.localfile:
+            continue

-def checkstatus(d):
+        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
+                bb.utils.remove(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)
+            except:
+                # Errors aren't fatal here
+                pass
+        else:
+            # Only check the checksums if we've not seen this item before
+            verify_checksum(u, ud, d)
+            Fetch.write_md5sum(u, ud, d)
+
+        bb.utils.unlockfile(lf)
+
+def checkstatus(d, urls = None):
    """
    Check all urls exist upstream
    init must have previously been called
    """
    urldata = init([], d, True)

-    for u in urldata:
+    if not urls:
+        urls = urldata
+
+    for u in urls:
        ud = urldata[u]
        m = ud.method
-        bb.msg.note(1, bb.msg.domain.Fetcher, "Testing URL %s" % u)
-        ret = m.checkstatus(u, ud, d)
+        logger.debug(1, "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:
-            bb.msg.fatal(bb.msg.domain.Fetcher, "URL %s doesn't work" % u)
+            # 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):
    """
@@ -216,27 +349,30 @@ def localpaths(d):
    urldata = init([], d, True)

    for u in urldata:
-        ud = urldata[u]      
+        ud = urldata[u]
        local.append(ud.localpath)

    return local

 srcrev_internal_call = False

+def get_autorev(d):
+    return get_srcrev(d)
+
 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 
+    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 
+    # 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  
+    # some number etc. hence the srcrev_internal_call tracking and the magic
    # "SRCREVINACTION" return value.
    #
    # Neater solutions welcome!
@@ -246,20 +382,21 @@ def get_srcrev(d):

    scms = []

-    # Only call setup_localpath on URIs which suppports_srcrev() 
+    # Only call setup_localpath on URIs which supports_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 ud.method.supports_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")
+        logger.error("SRCREV was used yet no valid SCM was found in SRC_URI")
        raise ParameterError

-    bb.data.setVar('__BB_DONT_CACHE','1', d)
+    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)
@@ -269,7 +406,7 @@ def get_srcrev(d):
    #
    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.")
+        logger.error("The SRCREV_FORMAT variable must be set when multiple SCMs are used.")
        raise ParameterError

    for scm in scms:
@@ -282,7 +419,7 @@ def get_srcrev(d):

 def localpath(url, d, cache = True):
    """
-    Called from the parser with cache=False since the cache isn't ready 
+    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)
@@ -301,28 +438,31 @@ def runfetchcmd(cmd, d, quiet = False):
    # 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', 'SSH_AUTH_SOCK', 'SSH_AGENT_PID', 'HOME']
+    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',
+                  'KRB5CCNAME', '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)
+            cmd = 'export ' + var + '=\"%s\"; %s' % (val, cmd)

-    bb.msg.debug(1, bb.msg.domain.Fetcher, "Running %s" % cmd)
+    logger.debug(1, "Running %s", cmd)

    # redirect stderr to stdout
    stdout_handle = os.popen(cmd + " 2>&1", "r")
    output = ""

-    while 1:
+    while True:
        line = stdout_handle.readline()
        if not line:
            break
        if not quiet:
-            print line,
+            print(line, end=' ')
        output += line

-    status =  stdout_handle.close() or 0
+    status = stdout_handle.close() or 0
    signal = status >> 8
    exitstatus = status & 0xff

@@ -333,13 +473,58 @@ def runfetchcmd(cmd, d, quiet = False):

    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:
+        logger.debug(1, "%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:
+                logger.debug(1, "No method for %s", uri)
+                continue
+
+            ud.setup_localpath(ld)
+
+            try:
+                if check:
+                    found = ud.method.checkstatus(newuri, ud, ld)
+                    if found:
+                        return found
+                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()
+                logger.debug(2, "Mirror fetch failure: %s", value)
+                bb.utils.remove(ud.localpath)
+                continue
+    return None
+
+
 class FetchData(object):
    """
    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) = bb.decodeurl(data.expand(url, d))
+        (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:
@@ -347,6 +532,16 @@ class FetchData(object):
        if not self.pswd and "pswd" in self.parm:
            self.pswd = self.parm["pswd"]
        self.setup = False
+
+        if "name" in self.parm:
+            self.md5_name = "%s.md5sum" % self.parm["name"]
+            self.sha256_name = "%s.sha256sum" % self.parm["name"]
+        else:
+            self.md5_name = "md5sum"
+            self.sha256_name = "sha256sum"
+        self.md5_expected = bb.data.getVarFlag("SRC_URI", self.md5_name, d)
+        self.sha256_expected = bb.data.getVarFlag("SRC_URI", self.sha256_name, d)
+
        for m in methods:
            if m.supports(url, self, d):
                self.method = m
@@ -358,17 +553,36 @@ class FetchData(object):
        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:
-            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)
-        self.md5 = self.localpath + '.md5'
-        self.lockfile = self.localpath + '.lock'
+            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):
@@ -386,10 +600,17 @@ 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
+    def _strip_leading_slashes(self, relpath):
+        """
+        Remove leading slash as os.path.join can't cope
+        """
+        while os.path.isabs(relpath):
+            relpath = relpath[1:]
+        return relpath

    def setUrls(self, urls):
        self.__urls = urls
@@ -405,7 +626,7 @@ class Fetch(object):
        """
        return False

-    def suppports_srcrev(self):
+    def supports_srcrev(self):
        """
        The fetcher supports auto source revisions (SRCREV)
        """
@@ -418,12 +639,23 @@ 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)
+        logger.info("URL %s could not be checked for status since no method exists.", url)
        return True

    def getSRCDate(urldata, d):
@@ -447,8 +679,8 @@ class Fetch(object):
        """
        Return:
            a) a source revision if specified
-	    b) True if auto srcrev is in action
-	    c) False otherwise
+            b) True if auto srcrev is in action
+            c) False otherwise
        """

        if 'rev' in ud.parm:
@@ -460,64 +692,45 @@ class Fetch(object):
        rev = None
        if 'name' in ud.parm:
            pn = data.getVar("PN", d, 1)
-            rev = data.getVar("SRCREV_pn-" + pn + "_" + ud.parm['name'], 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":
+        if rev == "SRCREVINACTION":
            return True
        return rev

    srcrev_internal_helper = staticmethod(srcrev_internal_helper)

-    def try_mirror(d, tarfn):
+    def localcount_internal_helper(ud, d):
        """
-        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
+        Return:
+            a) a locked localcount if specified
+            b) None otherwise
        """
-        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)
-            return True

-        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()
+        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

-        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)
-            httpproxy = data.getVar("http_proxy", d, True)
-            ftpproxy = data.getVar("ftp_proxy", d, True)
-            if httpproxy:
-                fetchcmd = "http_proxy=" + httpproxy + " " + fetchcmd
-            if ftpproxy:
-                fetchcmd = "ftp_proxy=" + ftpproxy + " " + fetchcmd
-            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)
+    localcount_internal_helper = staticmethod(localcount_internal_helper)

    def verify_md5sum(ud, got_sum):
        """
        Verify the md5sum we wanted with the one we got
        """
-        wanted_sum = None
-        if 'md5sum' in ud.parm:
-            wanted_sum = ud.parm['md5sum']
+        wanted_sum = ud.parm.get('md5sum')
        if not wanted_sum:
            return True

@@ -542,41 +755,49 @@ class Fetch(object):
        if not hasattr(self, "_latest_revision"):
            raise ParameterError

-        pd = persist_data.PersistData(d)
+        revs = persist_data.persist('BB_URI_HEADREVS', d)
        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
+        try:
+            return revs[key]
+        except KeyError:
+            revs[key] = rev = self._latest_revision(url, ud, d)
+            return rev

    def sortable_revision(self, url, ud, d):
        """
-        
+
        """
-        has_sortable = hasattr(self, "_sortable_revision")
-        if has_sortable:
+        if hasattr(self, "_sortable_revision"):
            return self._sortable_revision(url, ud, d)

-        pd = persist_data.PersistData(d)
+        localcounts = persist_data.persist('BB_URI_LOCALCOUNT', d)
        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")
-        count = pd.getValue("BB_URI_LOCALCOUNT", key + "_count")
+        last_rev = localcounts.get(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 = localcounts.get(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)
+        localcounts[key + '_rev'] = latest_rev
+        localcounts[key + '_count'] = count

        return str(count + "+" + latest_rev)

@@ -584,17 +805,18 @@ class Fetch(object):
        key = self._revision_key(url, ud, d)
        return "%s-%s" % (key, bb.data.getVar("PN", d, True) or "")

-import cvs
-import git
-import local
-import svn
-import wget
-import svk
-import ssh
-import perforce
-import bzr
-import hg
-import osc
+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(local.Local())
 methods.append(wget.Wget())
@@ -607,3 +829,4 @@ 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
@@ -25,12 +25,10 @@ BitBake 'Fetch' implementation for bzr.

 import os
 import sys
+import logging
 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
+from bb.fetch import Fetch, FetchError, runfetchcmd, logger

 class Bzr(Fetch):
    def supports(self, url, ud, d):
@@ -39,23 +37,20 @@ class Bzr(Fetch):
    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:]
+        relpath = self._strip_leading_slashes(ud.path)
        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)	
+            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.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):
@@ -66,23 +61,21 @@ class Bzr(Fetch):

        basecmd = data.expand('${FETCHCMD_bzr}', d)

-        proto = "http"
-        if "proto" in ud.parm:
-            proto = ud.parm["proto"]
+        proto =  ud.parm.get('proto', 'http')

        bzrroot = ud.host + ud.path

        options = []

-        if command is "revno":
+        if command == "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":
+            if command == "fetch":
                bzrcmd = "%s co %s %s://%s" % (basecmd, " ".join(options), proto, bzrroot)
-            elif command is "update":
+            elif command == "update":
                bzrcmd = "%s pull %s --overwrite" % (basecmd, " ".join(options))
            else:
                raise FetchError("Invalid bzr command %s" % command)
@@ -92,29 +85,31 @@ class Bzr(Fetch):
    def go(self, loc, ud, d):
        """Fetch url"""

-        # try to use the tarball stash
-        if Fetch.try_mirror(d, ud.localfile):
-            bb.msg.debug(1, bb.msg.domain.Fetcher, "%s already exists or was mirrored, skipping bzr checkout." % ud.localpath)
-            return
-
        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)
+            logger.debug(1, "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)))
+            bb.utils.remove(os.path.join(ud.pkgdir, os.path.basename(ud.pkgdir)), True)
            bzrcmd = self._buildbzrcommand(ud, d, "fetch")
-            bb.msg.debug(1, bb.msg.domain.Fetcher, "BZR Checkout %s" % loc)
-            bb.mkdirhier(ud.pkgdir)
+            logger.debug(1, "BZR Checkout %s", loc)
+            bb.utils.mkdirhier(ud.pkgdir)
            os.chdir(ud.pkgdir)
-            bb.msg.debug(1, bb.msg.domain.Fetcher, "Running %s" % bzrcmd)
+            logger.debug(1, "Running %s", bzrcmd)
            runfetchcmd(bzrcmd, d)

        os.chdir(ud.pkgdir)
+
+        scmdata = ud.parm.get("scmdata", "")
+        if scmdata == "keep":
+            tar_flags = ""
+        else:
+            tar_flags = "--exclude '.bzr' --exclude '.bzrtags'"
+
        # tar them up to a defined filename
        try:
-            runfetchcmd("tar -czf %s %s" % (ud.localpath, os.path.basename(ud.pkgdir)), d)
+            runfetchcmd("tar %s -czf %s %s" % (tar_flags, ud.localpath, os.path.basename(ud.pkgdir)), d)
        except:
            t, v, tb = sys.exc_info()
            try:
@@ -123,7 +118,7 @@ class Bzr(Fetch):
                pass
            raise t, v, tb

-    def suppports_srcrev(self):
+    def supports_srcrev(self):
        return True

    def _revision_key(self, url, ud, d):
@@ -136,7 +131,7 @@ class Bzr(Fetch):
        """
        Return the latest upstream revision number
        """
-        bb.msg.debug(2, bb.msg.domain.Fetcher, "BZR fetcher hitting network for %s" % url)
+        logger.debug(2, "BZR fetcher hitting network for %s", url)

        output = runfetchcmd(self._buildbzrcommand(ud, d, "revno"), d, True)

@@ -151,4 +146,3 @@ class Bzr(Fetch):

    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,12 +26,11 @@ BitBake build tools.
 #Based on functions from the base bb module, Copyright 2003 Holger Schurig
 #

-import os, re
+import os
+import logging
 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 Fetch, FetchError, MissingParameterError, logger

 class Cvs(Fetch):
    """
@@ -41,16 +40,14 @@ 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:
            raise MissingParameterError("cvs method needs a 'module' parameter")
        ud.module = ud.parm["module"]

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

        # Override the default date in certain cases
        if 'date' in ud.parm:
@@ -77,22 +74,9 @@ 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"]
-
-        localdir = ud.module
-        if "localdir" in ud.parm:
-            localdir = ud.parm["localdir"]
-
-        cvs_port = ""
-        if "port" in ud.parm:
-            cvs_port = ud.parm["port"]
+        method = ud.parm.get('method', 'pserver')
+        localdir = ud.parm.get('localdir', ud.module)
+        cvs_port = ud.parm.get('port', '')

        cvs_rsh = None
        if method == "ext":
@@ -141,38 +125,44 @@ class Cvs(Fetch):
            cvsupdatecmd = "CVS_RSH=\"%s\" %s" % (cvs_rsh, cvsupdatecmd)

        # create module directory
-        bb.msg.debug(2, bb.msg.domain.Fetcher, "Fetch: checking for module directory")
+        logger.debug(2, "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):
-            bb.msg.note(1, bb.msg.domain.Fetcher, "Update " + loc)
+        moddir = os.path.join(pkgdir, localdir)
+        if os.access(os.path.join(moddir, 'CVS'), os.R_OK):
+            logger.info("Update " + loc)
            # update sources there
            os.chdir(moddir)
            myret = os.system(cvsupdatecmd)
        else:
-            bb.msg.note(1, bb.msg.domain.Fetcher, "Fetch " + loc)
+            logger.info("Fetch " + loc)
            # check out sources there
-            bb.mkdirhier(pkgdir)
+            bb.utils.mkdirhier(pkgdir)
            os.chdir(pkgdir)
-            bb.msg.debug(1, bb.msg.domain.Fetcher, "Running %s" % cvscmd)
+            logger.debug(1, "Running %s", cvscmd)
            myret = os.system(cvscmd)

        if myret != 0 or not os.access(moddir, os.R_OK):
            try:
                os.rmdir(moddir)
            except OSError:
-                 pass
+                pass
            raise FetchError(ud.module)

+        scmdata = ud.parm.get("scmdata", "")
+        if scmdata == "keep":
+            tar_flags = ""
+        else:
+            tar_flags = "--exclude 'CVS'"
+
        # tar them up to a defined filename
        if 'fullpath' in ud.parm:
            os.chdir(pkgdir)
-            myret = os.system("tar -czf %s %s" % (ud.localpath, localdir))
+            myret = os.system("tar %s -czf %s %s" % (tar_flags, ud.localpath, localdir))
        else:
            os.chdir(moddir)
            os.chdir('..')
-            myret = os.system("tar -czf %s %s" % (ud.localpath, os.path.basename(moddir)))
+            myret = os.system("tar %s -czf %s %s" % (tar_flags, ud.localpath, os.path.basename(moddir)))

        if myret != 0:
            try:
--- a/bitbake/lib/bb/fetch/git.py
+++ b/bitbake/lib/bb/fetch/git.py
@@ -20,15 +20,22 @@ 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
+import bb.persist_data
 from   bb    import data
 from   bb.fetch import Fetch
-from   bb.fetch import FetchError
 from   bb.fetch import runfetchcmd
+from   bb.fetch import logger

 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.
@@ -46,90 +53,174 @@ class Git(Fetch):

        ud.branch = ud.parm.get("branch", "master")

+        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)	
+            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)	
+            ud.tag = self.latest_revision(url, ud, d)

-        ud.localfile = data.expand('git_%s%s_%s.tar.gz' % (ud.host, ud.path.replace('/', '.'), ud.tag), 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):
+        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 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('/', '.'))
+        repofile = os.path.join(data.getVar("DL_DIR", d, 1), ud.mirrortarball)

-        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)

        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)
-                runfetchcmd("tar -xzf %s" % (repofile), d)
-            else:
-                runfetchcmd("git clone -n %s://%s%s%s %s" % (ud.proto, username, ud.host, ud.path, repodir), 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

-        os.chdir(repodir)
-        # Remove all but the .git directory
-        if not self._contains_ref(ud.tag, d):
+        # 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.utils.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)
-            runfetchcmd("git fetch %s://%s%s%s %s" % (ud.proto, username, ud.host, ud.path, ud.branch), d)
-            runfetchcmd("git fetch --tags %s://%s%s%s" % (ud.proto, username, ud.host, ud.path), d)
-            runfetchcmd("git prune-packed", d)
-            runfetchcmd("git pack-redundant --all | xargs -r rm", d)
+            if 'fullclone' in ud.parm:
+                runfetchcmd("%s fetch --all" % (ud.basecmd), d)
+            else:
+                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)
+        # Generate a mirror tarball if needed
+        os.chdir(ud.clonedir)
        mirror_tarballs = data.getVar("BB_GENERATE_MIRROR_TARBALLS", d, True)
-        if mirror_tarballs != "0": 
-            bb.msg.note(1, bb.msg.domain.Fetcher, "Creating tarball of git repository")
+        if mirror_tarballs != "0" or 'fullclone' in ud.parm:
+            logger.info("Creating tarball of git repository")
            runfetchcmd("tar -czf %s %s" % (repofile, os.path.join(".", ".git", "*") ), d)

+        if 'fullclone' in ud.parm:
+            return
+
        if os.path.exists(codir):
            bb.utils.prunedir(codir)

-        bb.mkdirhier(codir)
-        os.chdir(repodir)
-        runfetchcmd("git read-tree %s" % (ud.tag), d)
-        runfetchcmd("git checkout-index -q -f --prefix=%s -a" % (os.path.join(codir, "git", "")), d)
+        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", "")
+
+        scmdata = ud.parm.get("scmdata", "")
+        if scmdata == "keep":
+            runfetchcmd("%s clone -n %s %s" % (ud.basecmd, ud.clonedir, coprefix), d)
+            os.chdir(coprefix)
+            runfetchcmd("%s checkout -q -f %s%s" % (ud.basecmd, ud.tag, readpathspec), d)
+        else:
+            bb.utils.mkdirhier(codir)
+            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")
+        logger.info("Creating tarball of git checkout")
        runfetchcmd("tar -czf %s %s" % (ud.localpath, os.path.join(".", "*") ), d)

-        os.chdir(repodir)
+        os.chdir(ud.clonedir)
        bb.utils.prunedir(codir)

-    def suppports_srcrev(self):
+    def supports_srcrev(self):
        return True

    def _contains_ref(self, tag, d):
-        output = runfetchcmd("git log --pretty=oneline -n 1 %s -- 2> /dev/null | wc -l" % tag, d, quiet=True)
+        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):
+    def _revision_key(self, url, ud, d, branch=False):
        """
        Return a unique key for the url
        """
-        return "git:" + ud.host + ud.path.replace('/', '.')
+        key = 'git:' + ud.host + ud.path.replace('/', '.')
+        if branch:
+            return key + ud.branch
+        else:
+            return key
+
+    def generate_revision_key(self, url, ud, d, branch=False):
+        key = self._revision_key(url, ud, d, branch)
+        return "%s-%s" % (key, bb.data.getVar("PN", d, True) or "")

    def _latest_revision(self, url, ud, d):
        """
@@ -140,50 +231,109 @@ class Git(Fetch):
        else:
            username = ""

-        output = runfetchcmd("git ls-remote %s://%s%s%s %s" % (ud.proto, username, ud.host, ud.path, ud.branch), d, True)
+        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 latest_revision(self, url, ud, d):
+        """
+        Look in the cache for the latest revision, if not present ask the SCM.
+        """
+        revs = bb.persist_data.persist('BB_URI_HEADREVS', d)
+
+        key = self.generate_revision_key(url, ud, d, branch=True)
+
+        try:
+            return revs[key]
+        except KeyError:
+            # Compatibility with old key format, no branch included
+            oldkey = self.generate_revision_key(url, ud, d, branch=False)
+            try:
+                rev = revs[oldkey]
+            except KeyError:
+                rev = self._latest_revision(url, ud, d)
+            else:
+                del revs[oldkey]
+            revs[key] = rev
+            return rev
+
+    def sortable_revision(self, url, ud, d):
+        """
+
+        """
+        localcounts = bb.persist_data.persist('BB_URI_LOCALCOUNT', d)
+        key = self.generate_revision_key(url, ud, d, branch=True)
+        oldkey = self.generate_revision_key(url, ud, d, branch=False)
+
+        latest_rev = self._build_revision(url, ud, d)
+        last_rev = localcounts.get(key + '_rev')
+        if last_rev is None:
+            last_rev = localcounts.get(oldkey + '_rev')
+            if last_rev is not None:
+                del localcounts[oldkey + '_rev']
+                localcounts[key + '_rev'] = last_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 = localcounts.get(key + '_count')
+        if count is None:
+            count = localcounts.get(oldkey + '_count')
+            if count is not None:
+                del localcounts[oldkey + '_count']
+                localcounts[key + '_count'] = 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)
+
+        localcounts[key + '_rev'] = latest_rev
+        localcounts[key + '_count'] = count
+
+        return str(count + "+" + latest_rev)
+
    def _build_revision(self, url, ud, d):
        return ud.tag

-    def _want_sortable_revision(self, url, ud, d):
-        return bb.data.getVar("BB_GIT_CLONE_FOR_SRCREV", d, True) or False
-
-    def _sortable_revision_disabled(self, url, ud, d):
+    def _sortable_buildindex_disabled(self, url, ud, d, rev):
        """
-        This is only called when _want_sortable_revision called true
-
-        We will have to get the updated revision.
+        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.
        """
-        gitsrcname = '%s%s' % (ud.host, ud.path.replace('/', '.'))
-        repodir = os.path.join(data.expand('${GITDIR}', d), gitsrcname)
-
-        key = "GIT_CACHED_REVISION-%s-%s"  % (gitsrcname, ud.tag)
-        if bb.data.getVar(key, d):
-            return bb.data.getVar(key, d)
-
-
-        # Runtime warning on wrongly configured sources
-        if ud.tag == "1":
-            bb.msg.error(1, bb.msg.domain.Fetcher, "SRCREV is '1'. This indicates a configuration error of %s" % url)
-            return "0+1"

        cwd = os.getcwd()

        # Check if we have the rev already
-        if not os.path.exists(repodir):
-            print "no repo"
+
+        if not os.path.exists(ud.clonedir):
+            print("no repo")
+            self.go(None, ud, d)
+            if not os.path.exists(ud.clonedir):
+                logger.error("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)

-        os.chdir(repodir)
-        if not self._contains_ref(ud.tag, d):
-            self.go(None, ud, d)
-
-        output = runfetchcmd("git rev-list %s -- 2> /dev/null | wc -l" % ud.tag, d, quiet=True)
+        output = runfetchcmd("%s rev-list %s -- 2> /dev/null | wc -l" % (ud.basecmd, rev), d, quiet=True)
        os.chdir(cwd)

-        sortable_revision = "%s+%s" % (output.split()[0], ud.tag)
-        bb.data.setVar(key, sortable_revision, d)
-        return sortable_revision
-        
-
+        buildindex = "%s" % output.split()[0]
+        logger.debug(1, "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
@@ -24,23 +24,29 @@ BitBake 'Fetch' implementation for mercurial DRCS (hg).
 #
 # Based on functions from the base bb module, Copyright 2003 Holger Schurig

-import os, re
+import os
 import sys
+import logging
 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
+from bb.fetch import logger

 class Hg(Fetch):
-    """Class to fetch a from mercurial repositories"""
+    """Class to fetch 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 forcefetch(self, url, ud, d):
+        revTag = ud.parm.get('rev', 'tip')
+        return revTag == "tip"
+
    def localpath(self, url, ud, d):
        if not "module" in ud.parm:
            raise MissingParameterError("hg method needs a 'module' parameter")
@@ -48,10 +54,7 @@ class Hg(Fetch):
        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:]
+        relpath = self._strip_leading_slashes(ud.path)
        ud.pkgdir = os.path.join(data.expand('${HGDIR}', d), ud.host, relpath)
        ud.moddir = os.path.join(ud.pkgdir, ud.module)

@@ -78,9 +81,7 @@ class Hg(Fetch):

        basecmd = data.expand('${FETCHCMD_hg}', d)

-        proto = "http"
-        if "proto" in ud.parm:
-            proto = ud.parm["proto"]
+        proto = ud.parm.get('proto', 'http')

        host = ud.host
        if proto == "file":
@@ -116,39 +117,41 @@ class Hg(Fetch):
    def go(self, loc, ud, d):
        """Fetch url"""

-        # try to use the tarball stash
-        if Fetch.try_mirror(d, ud.localfile):
-            bb.msg.debug(1, bb.msg.domain.Fetcher, "%s already exists or was mirrored, skipping hg checkout." % ud.localpath)
-            return
-
-        bb.msg.debug(2, bb.msg.domain.Fetcher, "Fetch: checking for module directory '" + ud.moddir + "'")
+        logger.debug(2, "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)
+            logger.info("Update " + loc)
            # update sources there
            os.chdir(ud.moddir)
-            bb.msg.debug(1, bb.msg.domain.Fetcher, "Running %s" % updatecmd)
+            logger.debug(1, "Running %s", updatecmd)
            runfetchcmd(updatecmd, d)

        else:
            fetchcmd = self._buildhgcommand(ud, d, "fetch")
-            bb.msg.note(1, bb.msg.domain.Fetcher, "Fetch " + loc)
+            logger.info("Fetch " + loc)
            # check out sources there
-            bb.mkdirhier(ud.pkgdir)
+            bb.utils.mkdirhier(ud.pkgdir)
            os.chdir(ud.pkgdir)
-            bb.msg.debug(1, bb.msg.domain.Fetcher, "Running %s" % fetchcmd)
+            logger.debug(1, "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
+
+        # 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)
+        os.chdir(ud.moddir)
+        logger.debug(1, "Running %s", updatecmd)
        runfetchcmd(updatecmd, d)

+        scmdata = ud.parm.get("scmdata", "")
+        if scmdata == "keep":
+            tar_flags = ""
+        else:
+            tar_flags = "--exclude '.hg' --exclude '.hgrags'"
+
        os.chdir(ud.pkgdir)
        try:
-            runfetchcmd("tar -czf %s %s" % (ud.localpath, ud.module), d)
+            runfetchcmd("tar %s -czf %s %s" % (tar_flags, ud.localpath, ud.module), d)
        except:
            t, v, tb = sys.exc_info()
            try:
@@ -157,7 +160,7 @@ class Hg(Fetch):
                pass
            raise t, v, tb

-    def suppports_srcrev(self):
+    def supports_srcrev(self):
        return True

    def _latest_revision(self, url, ud, d):
@@ -175,4 +178,3 @@ class Hg(Fetch):
        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,17 +25,18 @@ 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):
        """
@@ -47,7 +48,7 @@ class Local(Fetch):
        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:
@@ -65,8 +66,8 @@ class Local(Fetch):
        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
+            logger.info("URL %s looks like a glob and was therefore not checked.", url)
+            return True
        if os.path.exists(urldata.localpath):
-           return True
+            return True
        return False
--- a/bitbake/lib/bb/fetch/osc.py
+++ b/bitbake/lib/bb/fetch/osc.py
@@ -8,15 +8,17 @@ Based on the svn "Fetch" implementation.

 import  os
 import  sys
+import logging
 import  bb
 from    bb       import data
+from    bb       import utils
 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 
+    """Class to fetch a module or modules from Opensuse build server
       repositories."""

    def supports(self, url, ud, d):
@@ -32,10 +34,7 @@ class Osc(Fetch):
        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:]
+        relpath = self._strip_leading_slashes(ud.path)
        ud.pkgdir = os.path.join(data.expand('${OSCDIR}', d), ud.host)
        ud.moddir = os.path.join(ud.pkgdir, relpath, ud.module)

@@ -61,10 +60,8 @@ class Osc(Fetch):

        basecmd = data.expand('${FETCHCMD_osc}', d)

-        proto = "ocs"
-        if "proto" in ud.parm:
-            proto = ud.parm["proto"]
-        
+        proto = ud.parm.get('proto', 'ocs')
+
        options = []

        config = "-c %s" % self.generate_config(ud, d)
@@ -72,10 +69,7 @@ class Osc(Fetch):
        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:]
+        coroot = self._strip_leading_slashes(ud.path)

        if command is "fetch":
            osccmd = "%s %s co %s/%s %s" % (basecmd, config, coroot, ud.module, " ".join(options))
@@ -91,29 +85,24 @@ class Osc(Fetch):
        Fetch url
        """

-        # Try to use the tarball stash
-        if Fetch.try_mirror(d, ud.localfile):
-            bb.msg.debug(1, bb.msg.domain.Fetcher, "%s already exists or was mirrored, skipping osc checkout." % ud.localpath)
-            return
-
-        bb.msg.debug(2, bb.msg.domain.Fetcher, "Fetch: checking for module directory '" + ud.moddir + "'")
+        logger.debug(2, "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)
+            logger.info("Update "+ loc)
            # update sources there
            os.chdir(ud.moddir)
-            bb.msg.debug(1, bb.msg.domain.Fetcher, "Running %s" % oscupdatecmd)
+            logger.debug(1, "Running %s", oscupdatecmd)
            runfetchcmd(oscupdatecmd, d)
        else:
            oscfetchcmd = self._buildosccommand(ud, d, "fetch")
-            bb.msg.note(1, bb.msg.domain.Fetcher, "Fetch " + loc)
+            logger.info("Fetch " + loc)
            # check out sources there
-            bb.mkdirhier(ud.pkgdir)
+            bb.utils.mkdirhier(ud.pkgdir)
            os.chdir(ud.pkgdir)
-            bb.msg.debug(1, bb.msg.domain.Fetcher, "Running %s" % oscfetchcmd)
+            logger.debug(1, "Running %s", oscfetchcmd)
            runfetchcmd(oscfetchcmd, d)
-        
+
        os.chdir(os.path.join(ud.pkgdir + ud.path))
        # tar them up to a defined filename
        try:
@@ -134,9 +123,8 @@ class Osc(Fetch):
        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) 
+        config_path = os.path.join(data.expand('${OSCDIR}', d), "oscrc")
+        bb.utils.remove(config_path)

        f = open(config_path, 'w')
        f.write("[general]\n")
@@ -151,5 +139,5 @@ class Osc(Fetch):
        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,28 @@ 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 logging
 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 logger

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

-    def doparse(url,d):
+    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,19 +56,19 @@ 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"];
@@ -86,19 +88,19 @@ class Perforce(Fetch):
            depot += "@%s" % (p4date)

        p4cmd = data.getVar('FETCHCOMMAND_p4', d, 1)
-        bb.msg.debug(1, bb.msg.domain.Fetcher, "Running %s%s changes -m 1 %s" % (p4cmd, p4opt, depot))
+        logger.debug(1, "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))
+        logger.debug(1, "READ %s", cset)
        if not cset:
            return -1

        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

@@ -111,12 +113,11 @@ class Perforce(Fetch):
        if which != -1:
            base = path[:which]

-        if base[0] == "/":
-            base = base[1:]
+        base = self._strip_leading_slashes(base)

        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)

@@ -125,22 +126,14 @@ class Perforce(Fetch):
        Fetch urls
        """

-        # try to use the tarball stash
-        if 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('/...')]
        else:
            path = depot

-        if "module" in parm:
-            module = parm["module"]
-        else:
-            module = os.path.basename(path)
+        module = parm.get('module', os.path.basename(path))

        localdata = data.createCopy(d)
        data.setVar('OVERRIDES', "p4:%s" % data.getVar('OVERRIDES', localdata), localdata)
@@ -160,33 +153,33 @@ class Perforce(Fetch):
        p4cmd = data.getVar('FETCHCOMMAND', localdata, 1)

        # create temp directory
-        bb.msg.debug(2, bb.msg.domain.Fetcher, "Fetch: creating temporary directory")
-        bb.mkdirhier(data.expand('${WORKDIR}', localdata))
+        logger.debug(2, "Fetch: creating temporary directory")
+        bb.utils.mkdirhier(data.expand('${WORKDIR}', localdata))
        data.setVar('TMPBASE', data.expand('${WORKDIR}/oep4.XXXXXX', localdata), localdata)
        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.")
+            logger.error("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%s files %s" % (p4cmd, p4opt, depot))
+        logger.info("Fetch " + loc)
+        logger.info("%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))
+            logger.error("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":
@@ -195,11 +188,11 @@ class Perforce(Fetch):
            dest = list[0][len(path)+1:]
            where = dest.find("#")

-            os.system("%s%s print -o %s/%s %s" % (p4cmd, p4opt, 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")
+            logger.error("Fetch:  No files gathered from the P4 fetch")
            raise FetchError(module)

        myret = os.system("tar -czf %s %s" % (ud.localpath, module))
@@ -210,6 +203,4 @@ class Perforce(Fetch):
                pass
            raise FetchError(module)
        # cleanup
-        os.system('rm -rf %s' % tmpfile)
-
-
+        bb.utils.prunedir(tmpfile)
--- a/bitbake/lib/bb/fetch/repo.py
+++ b/bitbake/lib/bb/fetch/repo.py
@@ -0,0 +1,98 @@
+# 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".
+        """
+
+        ud.proto = ud.parm.get('protocol', 'git')
+        ud.branch = ud.parm.get('branch', 'master')
+        ud.manifest = ud.parm.get('manifest', 'default.xml')
+        if not ud.manifest.endswith('.xml'):
+            ud.manifest += '.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):
+            logger.debug(1, "%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.utils.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)
+
+        scmdata = ud.parm.get("scmdata", "")
+        if scmdata == "keep":
+            tar_flags = ""
+        else:
+            tar_flags = "--exclude '.repo' --exclude '.git'"
+
+        # Create a cache
+        runfetchcmd("tar %s -czf %s %s" % (tar_flags, ud.localpath, os.path.join(".", "*") ), d)
+
+    def supports_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
@@ -26,17 +26,19 @@ 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
+import logging
 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 logger

 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']

@@ -46,25 +48,18 @@ class Svk(Fetch):
        else:
            ud.module = ud.parm["module"]

-        ud.revision = ""
-        if 'rev' in ud.parm:
-            ud.revision = ud.parm['rev']
+        ud.revision = ud.parm.get('rev', "")

        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
+        return ud.date == "now"

    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" % (ud.date, svkroot, ud.module)
@@ -75,19 +70,19 @@ class Svk(Fetch):
        # create temp directory
        localdata = data.createCopy(d)
        data.update_data(localdata)
-        bb.msg.debug(2, bb.msg.domain.Fetcher, "Fetch: creating temporary directory")
-        bb.mkdirhier(data.expand('${WORKDIR}', localdata))
+        logger.debug(2, "Fetch: creating temporary directory")
+        bb.utils.mkdirhier(data.expand('${WORKDIR}', localdata))
        data.setVar('TMPBASE', data.expand('${WORKDIR}/oesvk.XXXXXX', localdata), localdata)
        tmppipe = os.popen(data.getVar('MKTEMPDIRCMD', localdata, 1) or "false")
        tmpfile = tmppipe.readline().strip()
        if not tmpfile:
-            bb.msg.error(bb.msg.domain.Fetcher, "Fetch: unable to create temporary directory.. make sure 'mktemp' is in the PATH.")
+            logger.error("Fetch: unable to create temporary directory.. make sure 'mktemp' is in the PATH.")
            raise FetchError(ud.module)

        # check out sources there
        os.chdir(tmpfile)
-        bb.msg.note(1, bb.msg.domain.Fetcher, "Fetch " + loc)
-        bb.msg.debug(1, bb.msg.domain.Fetcher, "Running %s" % svkcmd)
+        logger.info("Fetch " + loc)
+        logger.debug(1, "Running %s", svkcmd)
        myret = os.system(svkcmd)
        if myret != 0:
            try:
@@ -106,4 +101,4 @@ class Svk(Fetch):
                pass
            raise FetchError(ud.module)
        # cleanup
-        os.system('rm -rf %s' % tmpfile)
+        bb.utils.prunedir(tmpfile)
--- a/bitbake/lib/bb/fetch/svn.py
+++ b/bitbake/lib/bb/fetch/svn.py
@@ -23,14 +23,16 @@ BitBake 'Fetch' implementation for svn.
 #
 # Based on functions from the base bb module, Copyright 2003 Holger Schurig

-import os, re
+import os
 import sys
+import logging
 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
+from   bb.fetch import logger

 class Svn(Fetch):
    """Class to fetch a module or modules from svn repositories"""
@@ -47,10 +49,7 @@ class Svn(Fetch):
        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:]
+        relpath = self._strip_leading_slashes(ud.path)
        ud.pkgdir = os.path.join(data.expand('${SVNDIR}', d), ud.host, relpath)
        ud.moddir = os.path.join(ud.pkgdir, ud.module)

@@ -78,7 +77,7 @@ class Svn(Fetch):
                    ud.revision = rev
                    ud.date = ""
                else:
-                    ud.revision = ""		
+                    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)

@@ -92,9 +91,7 @@ class Svn(Fetch):

        basecmd = data.expand('${FETCHCMD_svn}', d)

-        proto = "svn"
-        if "proto" in ud.parm:
-            proto = ud.parm["proto"]
+        proto = ud.parm.get('proto', 'svn')

        svn_rsh = None
        if proto == "svn+ssh" and "rsh" in ud.parm:
@@ -136,33 +133,34 @@ class Svn(Fetch):
    def go(self, loc, ud, d):
        """Fetch url"""

-        # try to use the tarball stash
-        if 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
-
-        bb.msg.debug(2, bb.msg.domain.Fetcher, "Fetch: checking for module directory '" + ud.moddir + "'")
+        logger.debug(2, "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)
+            logger.info("Update " + loc)
            # update sources there
            os.chdir(ud.moddir)
-            bb.msg.debug(1, bb.msg.domain.Fetcher, "Running %s" % svnupdatecmd)
+            logger.debug(1, "Running %s", svnupdatecmd)
            runfetchcmd(svnupdatecmd, d)
        else:
            svnfetchcmd = self._buildsvncommand(ud, d, "fetch")
-            bb.msg.note(1, bb.msg.domain.Fetcher, "Fetch " + loc)
+            logger.info("Fetch " + loc)
            # check out sources there
-            bb.mkdirhier(ud.pkgdir)
+            bb.utils.mkdirhier(ud.pkgdir)
            os.chdir(ud.pkgdir)
-            bb.msg.debug(1, bb.msg.domain.Fetcher, "Running %s" % svnfetchcmd)
+            logger.debug(1, "Running %s", svnfetchcmd)
            runfetchcmd(svnfetchcmd, d)

+        scmdata = ud.parm.get("scmdata", "")
+        if scmdata == "keep":
+            tar_flags = ""
+        else:
+            tar_flags = "--exclude '.svn'"
+
        os.chdir(ud.pkgdir)
        # tar them up to a defined filename
        try:
-            runfetchcmd("tar -czf %s %s" % (ud.localpath, ud.module), d)
+            runfetchcmd("tar %s -czf %s %s" % (tar_flags, ud.localpath, ud.module), d)
        except:
            t, v, tb = sys.exc_info()
            try:
@@ -171,7 +169,7 @@ class Svn(Fetch):
                pass
            raise t, v, tb

-    def suppports_srcrev(self):
+    def supports_srcrev(self):
        return True

    def _revision_key(self, url, ud, d):
@@ -184,7 +182,7 @@ class Svn(Fetch):
        """
        Return the latest upstream revision number
        """
-        bb.msg.debug(2, bb.msg.domain.Fetcher, "SVN fetcher hitting network for %s" % url)
+        logger.debug(2, "SVN fetcher hitting network for %s", url)

        output = runfetchcmd("LANG=C LC_ALL=C " + self._buildsvncommand(ud, d, "info"), d, True)

--- a/bitbake/lib/bb/fetch/wget.py
+++ b/bitbake/lib/bb/fetch/wget.py
@@ -25,26 +25,26 @@ BitBake build tools.
 #
 # Based on functions from the base bb module, Copyright 2003 Holger Schurig

-import os, re
+import os
+import logging
 import bb
+import urllib
 from   bb import data
-from   bb.fetch import Fetch
-from   bb.fetch import FetchError
-from   bb.fetch import uri_replace
+from   bb.fetch import Fetch, FetchError, encodeurl, decodeurl, logger, 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)
+        ud.localfile = data.expand(urllib.unquote(ud.basename), d)

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

@@ -61,42 +61,20 @@ class Wget(Fetch):
                fetchcmd = data.getVar("FETCHCOMMAND", d, 1)

            uri = uri.split(";")[0]
-            uri_decoded = list(bb.decodeurl(uri))
+            uri_decoded = list(decodeurl(uri))
            uri_type = uri_decoded[0]
            uri_host = uri_decoded[1]

-            bb.msg.note(1, bb.msg.domain.Fetcher, "fetch " + uri)
            fetchcmd = fetchcmd.replace("${URI}", uri.split(";")[0])
            fetchcmd = fetchcmd.replace("${FILE}", ud.basename)
-            httpproxy = None
-            ftpproxy = None
-            if uri_type == 'http':
-                httpproxy = data.getVar("HTTP_PROXY", d, True)
-                httpproxy_ignore = (data.getVar("HTTP_PROXY_IGNORE", d, True) or "").split()
-                for p in httpproxy_ignore:
-                    if uri_host.endswith(p):
-                        httpproxy = None
-                        break
-            if uri_type == 'ftp':
-                ftpproxy = data.getVar("FTP_PROXY", d, True)
-                ftpproxy_ignore = (data.getVar("HTTP_PROXY_IGNORE", d, True) or "").split()
-                for p in ftpproxy_ignore:
-                    if uri_host.endswith(p):
-                        ftpproxy = None
-                        break
-            if httpproxy:
-                fetchcmd = "http_proxy=" + httpproxy + " " + fetchcmd
-            if ftpproxy:
-                fetchcmd = "ftp_proxy=" + ftpproxy + " " + fetchcmd
-            bb.msg.debug(2, bb.msg.domain.Fetcher, "executing " + fetchcmd)
-            ret = os.system(fetchcmd)
-            if ret != 0:
-                return False
+            logger.info("fetch " + uri)
+            logger.debug(2, "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))
+                logger.debug(2, "The fetch command for %s returned success but %s doesn't exist?...", uri, ud.localpath)
                return False

            return True
@@ -105,24 +83,9 @@ 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 True
-
        if fetch_uri(uri, ud, localdata):
            return True

-        # 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 True
-
        raise FetchError(uri)


--- a/bitbake/lib/bb/fetch2/init.py
+++ b/bitbake/lib/bb/fetch2/init.py
--- a/bitbake/lib/bb/fetch2/bzr.py
+++ b/bitbake/lib/bb/fetch2/bzr.py
@@ -0,0 +1,143 @@
+"""
+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 logging
+import bb
+from bb import data
+from bb.fetch2 import FetchMethod
+from bb.fetch2 import FetchError
+from bb.fetch2 import runfetchcmd
+from bb.fetch2 import logger
+
+class Bzr(FetchMethod):
+    def supports(self, url, ud, d):
+        return ud.type in ['bzr']
+
+    def urldata_init(self, ud, d):
+        """
+        init bzr specific variable within url data
+        """
+        # Create paths to bzr checkouts
+        relpath = self._strip_leading_slashes(ud.path)
+        ud.pkgdir = os.path.join(data.expand('${BZRDIR}', d), ud.host, relpath)
+
+        ud.setup_revisons(d)
+
+        if not ud.revision:
+            ud.revision = self.latest_revision(ud.url, ud, d)
+
+        ud.localfile = data.expand('bzr_%s_%s_%s.tar.gz' % (ud.host, ud.path.replace('/', '.'), ud.revision), d)
+
+    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 =  ud.parm.get('proto', 'http')
+
+        bzrroot = ud.host + ud.path
+
+        options = []
+
+        if command == "revno":
+            bzrcmd = "%s revno %s %s://%s" % (basecmd, " ".join(options), proto, bzrroot)
+        else:
+            if ud.revision:
+                options.append("-r %s" % ud.revision)
+
+            if command == "fetch":
+                bzrcmd = "%s co %s %s://%s" % (basecmd, " ".join(options), proto, bzrroot)
+            elif command == "update":
+                bzrcmd = "%s pull %s --overwrite" % (basecmd, " ".join(options))
+            else:
+                raise FetchError("Invalid bzr command %s" % command, ud.url)
+
+        return bzrcmd
+
+    def download(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")
+            logger.debug(1, "BZR Update %s", loc)
+            bb.fetch2.check_network_access(d, bzrcmd, ud.url)
+            os.chdir(os.path.join (ud.pkgdir, os.path.basename(ud.path)))
+            runfetchcmd(bzrcmd, d)
+        else:
+            bb.utils.remove(os.path.join(ud.pkgdir, os.path.basename(ud.pkgdir)), True)
+            bzrcmd = self._buildbzrcommand(ud, d, "fetch")
+            bb.fetch2.check_network_access(d, bzrcmd, ud.url)
+            logger.debug(1, "BZR Checkout %s", loc)
+            bb.utils.mkdirhier(ud.pkgdir)
+            os.chdir(ud.pkgdir)
+            logger.debug(1, "Running %s", bzrcmd)
+            runfetchcmd(bzrcmd, d)
+
+        os.chdir(ud.pkgdir)
+
+        scmdata = ud.parm.get("scmdata", "")
+        if scmdata == "keep":
+            tar_flags = ""
+        else:
+            tar_flags = "--exclude '.bzr' --exclude '.bzrtags'"
+
+        # tar them up to a defined filename
+        runfetchcmd("tar %s -czf %s %s" % (tar_flags, ud.localpath, os.path.basename(ud.pkgdir)), d, cleanup = [ud.localpath])
+
+    def supports_srcrev(self):
+        return True
+
+    def _revision_key(self, url, ud, d, name):
+        """
+        Return a unique key for the url
+        """
+        return "bzr:" + ud.pkgdir
+
+    def _latest_revision(self, url, ud, d, name):
+        """
+        Return the latest upstream revision number
+        """
+        logger.debug(2, "BZR fetcher hitting network for %s", url)
+
+        bb.fetch2.check_network_access(d, self._buildbzrcommand(ud, d, "revno"), ud.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/fetch2/cvs.py
+++ b/bitbake/lib/bb/fetch2/cvs.py
@@ -0,0 +1,181 @@
+# ex:ts=4:sw=4:sts=4:et
+# -*- tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*-
+"""
+BitBake 'Fetch' implementations
+
+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.
+#
+#Based on functions from the base bb module, Copyright 2003 Holger Schurig
+#
+
+import os
+import logging
+import bb
+from   bb import data
+from bb.fetch2 import FetchMethod, FetchError, MissingParameterError, logger
+from bb.fetch2 import runfetchcmd
+
+class Cvs(FetchMethod):
+    """
+    Class to fetch a module or modules from cvs repositories
+    """
+    def supports(self, url, ud, d):
+        """
+        Check to see if a given url can be fetched with cvs.
+        """
+        return ud.type in ['cvs']
+
+    def urldata_init(self, ud, d):
+        if not "module" in ud.parm:
+            raise MissingParameterError("module", ud.url)
+        ud.module = ud.parm["module"]
+
+        ud.tag = ud.parm.get('tag', "")
+
+        # Override the default date in certain cases
+        if 'date' in ud.parm:
+            ud.date = ud.parm['date']
+        elif ud.tag:
+            ud.date = ""
+
+        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)
+
+    def need_update(self, url, ud, d):
+        if (ud.date == "now"):
+            return True
+        if not os.path.exists(ud.localpath):
+            return True
+        return False
+
+    def download(self, loc, ud, d):
+
+        method = ud.parm.get('method', 'pserver')
+        localdir = ud.parm.get('localdir', ud.module)
+        cvs_port = ud.parm.get('port', '')
+
+        cvs_rsh = None
+        if method == "ext":
+            if "rsh" in ud.parm:
+                cvs_rsh = ud.parm["rsh"]
+
+        if method == "dir":
+            cvsroot = ud.path
+        else:
+            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:
+            # 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)
+
+        localdata = data.createCopy(d)
+        data.setVar('OVERRIDES', "cvs:%s" % data.getVar('OVERRIDES', localdata), localdata)
+        data.update_data(localdata)
+
+        data.setVar('CVSROOT', cvsroot, localdata)
+        data.setVar('CVSCOOPTS', " ".join(options), localdata)
+        data.setVar('CVSMODULE', ud.module, localdata)
+        cvscmd = data.getVar('FETCHCOMMAND', localdata, True)
+        cvsupdatecmd = data.getVar('UPDATECOMMAND', localdata, True)
+
+        if cvs_rsh:
+            cvscmd = "CVS_RSH=\"%s\" %s" % (cvs_rsh, cvscmd)
+            cvsupdatecmd = "CVS_RSH=\"%s\" %s" % (cvs_rsh, cvsupdatecmd)
+
+        # create module directory
+        logger.debug(2, "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):
+            logger.info("Update " + loc)
+            bb.fetch2.check_network_access(d, cvsupdatecmd, ud.url)
+            # update sources there
+            os.chdir(moddir)
+            cmd = cvsupdatecmd
+        else:
+            logger.info("Fetch " + loc)
+            # check out sources there
+            bb.utils.mkdirhier(pkgdir)
+            os.chdir(pkgdir)
+            logger.debug(1, "Running %s", cvscmd)
+            bb.fetch2.check_network_access(d, cvscmd, ud.url)
+            cmd = cvscmd
+
+        runfetchcmd(cmd, d, cleanup = [moddir])
+
+        if not os.access(moddir, os.R_OK):
+            raise FetchError("Directory %s was not readable despite sucessful fetch?!" % moddir, ud.url)
+
+        scmdata = ud.parm.get("scmdata", "")
+        if scmdata == "keep":
+            tar_flags = ""
+        else:
+            tar_flags = "--exclude 'CVS'"
+
+        # tar them up to a defined filename
+        if 'fullpath' in ud.parm:
+            os.chdir(pkgdir)
+            cmd = "tar %s -czf %s %s" % (tar_flags, ud.localpath, localdir)
+        else:
+            os.chdir(moddir)
+            os.chdir('..')
+            cmd = "tar %s -czf %s %s" % (tar_flags, ud.localpath, os.path.basename(moddir))
+
+        runfetchcmd(cmd, d, cleanup = [ud.localpath])
+
+    def clean(self, ud, d):
+        """ Clean CVS Files and tarballs """
+        
+        pkg = data.expand('${PN}', d)
+        localdata = data.createCopy(d)
+        data.setVar('OVERRIDES', "cvs:%s" % data.getVar('OVERRIDES', localdata), localdata)
+        data.update_data(localdata)
+        pkgdir = os.path.join(data.expand('${CVSDIR}', localdata), pkg)
+
+        bb.utils.remove(pkgdir, True)
+        bb.utils.remove(ud.localpath)
+
--- a/bitbake/lib/bb/fetch2/git.py
+++ b/bitbake/lib/bb/fetch2/git.py
@@ -0,0 +1,315 @@
+# ex:ts=4:sw=4:sts=4:et
+# -*- tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*-
+"""
+BitBake 'Fetch' git implementation
+
+git fetcher support the SRC_URI with format of:
+SRC_URI = "git://some.host/somepath;OptionA=xxx;OptionB=xxx;..."
+
+Supported SRC_URI options are:
+
+- branch
+   The git branch to retrieve from. The default is "master"
+
+   this option also support multiple branches fetching, branches
+   are seperated by comma. in multiple branches case, the name option
+   must have the same number of names to match the branches, which is
+   used to specify the SRC_REV for the branch
+   e.g:
+   SRC_URI="git://some.host/somepath;branch=branchX,branchY;name=nameX,nameY"
+   SRCREV_nameX = "xxxxxxxxxxxxxxxxxxxx"
+   SRCREV_nameY = "YYYYYYYYYYYYYYYYYYYY"
+
+- tag
+    The git tag to retrieve. The default is "master"
+
+- protocol
+   The method to use to access the repository. Common options are "git",
+   "http", "file" and "rsync". The default is "git"
+
+- rebaseable
+   rebaseable indicates that the upstream git repo may rebase in the future,
+   and current revision may disappear from upstream repo. This option will
+   reminder fetcher to preserve local cache carefully for future use.
+   The default value is "0", set rebaseable=1 for rebaseable git repo
+
+- nocheckout
+   Don't checkout source code when unpacking. set this option for the recipe
+   who has its own routine to checkout code.
+   The default is "0", set nocheckout=1 if needed.
+
+"""
+
+#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.fetch2 import FetchMethod
+from   bb.fetch2 import runfetchcmd
+from   bb.fetch2 import logger
+
+class Git(FetchMethod):
+    """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.
+        """
+        return ud.type in ['git']
+
+    def urldata_init(self, ud, d):
+        """
+        init git specific variable within url data
+        so that the git method like latest_revision() can work
+        """
+        if 'protocol' in ud.parm:
+            ud.proto = ud.parm['protocol']
+        elif not ud.host:
+            ud.proto = 'file'
+        else:
+            ud.proto = "git"
+
+        if not ud.proto in ('git', 'file', 'ssh', 'http', 'https', 'rsync'):
+            raise bb.fetch2.ParameterError("Invalid protocol type", ud.url)
+
+        ud.nocheckout = ud.parm.get("nocheckout","0") == "1"
+
+        ud.rebaseable = ud.parm.get("rebaseable","0") == "1"
+
+        branches = ud.parm.get("branch", "master").split(',')
+        if len(branches) != len(ud.names):
+            raise bb.fetch2.ParameterError("The number of name and branch parameters is not balanced", ud.url)
+        ud.branches = {}
+        for name in ud.names:
+            branch = branches[ud.names.index(name)]
+            ud.branches[name] = branch
+
+        ud.basecmd = data.getVar("FETCHCMD_git", d, True) or "git"
+
+        ud.write_tarballs = ((data.getVar("BB_GENERATE_MIRROR_TARBALLS", d, True) or "0") != "0") or ud.rebaseable
+
+        ud.setup_revisons(d)
+
+        for name in ud.names:
+            # Ensure anything that doesn't look like a sha256 checksum/revision is translated into one
+            if not ud.revisions[name] or len(ud.revisions[name]) != 40  or (False in [c in "abcdef0123456789" for c in ud.revisions[name]]):
+                ud.branches[name] = ud.revisions[name]
+                ud.revisions[name] = self.latest_revision(ud.url, ud, d, name)
+
+        gitsrcname = '%s%s' % (ud.host, ud.path.replace('/', '.'))
+        # for rebaseable git repo, it is necessary to keep mirror tar ball
+        # per revision, so that even the revision disappears from the
+        # upstream repo in the future, the mirror will remain intact and still
+        # contains the revision
+        if ud.rebaseable:
+            for name in ud.names:
+                gitsrcname = gitsrcname + '_' + ud.revisions[name]
+        ud.mirrortarball = 'git2_%s.tar.gz' % (gitsrcname)
+        ud.fullmirror = os.path.join(data.getVar("DL_DIR", d, True), ud.mirrortarball)
+        ud.clonedir = os.path.join(data.expand('${GITDIR}', d), gitsrcname)
+
+        ud.localfile = ud.clonedir
+
+    def localpath(self, url, ud, d):
+        return ud.clonedir
+
+    def need_update(self, u, ud, d):
+        if not os.path.exists(ud.clonedir):
+            return True
+        os.chdir(ud.clonedir)
+        for name in ud.names:
+            if not self._contains_ref(ud.revisions[name], d):
+                return True
+        if ud.write_tarballs and not os.path.exists(ud.fullmirror):
+            return True
+        return False
+
+    def try_premirror(self, u, ud, d):
+        # If we don't do this, updating an existing checkout with only premirrors
+        # is not possible
+        if bb.data.getVar("BB_FETCH_PREMIRRORONLY", d, True) is not None:
+            return True
+        if os.path.exists(ud.clonedir):
+            return False
+        return True
+
+    def download(self, loc, ud, d):
+        """Fetch url"""
+
+        if ud.user:
+            username = ud.user + '@'
+        else:
+            username = ""
+
+        ud.repochanged = not os.path.exists(ud.fullmirror)
+
+        # If the checkout doesn't exist and the mirror tarball does, extract it
+        if not os.path.exists(ud.clonedir) and os.path.exists(ud.fullmirror):
+            bb.utils.mkdirhier(ud.clonedir)
+            os.chdir(ud.clonedir)
+            runfetchcmd("tar -xzf %s" % (ud.fullmirror), d)
+
+        repourl = "%s://%s%s%s" % (ud.proto, username, ud.host, ud.path)
+
+        # If the repo still doesn't exist, fallback to cloning it
+        if not os.path.exists(ud.clonedir):
+            clone_cmd = "%s clone --bare --mirror %s %s" % (ud.basecmd, repourl, ud.clonedir)
+            bb.fetch2.check_network_access(d, clone_cmd)
+            runfetchcmd(clone_cmd, d)
+
+        os.chdir(ud.clonedir)
+        # Update the checkout if needed
+        needupdate = False
+        for name in ud.names:
+            if not self._contains_ref(ud.revisions[name], d):
+                needupdate = True
+        if needupdate:
+            try: 
+                runfetchcmd("%s remote prune origin" % ud.basecmd, d) 
+                runfetchcmd("%s remote rm origin" % ud.basecmd, d) 
+            except bb.fetch2.FetchError:
+                logger.debug(1, "No Origin")
+
+            runfetchcmd("%s remote add --mirror=fetch origin %s" % (ud.basecmd, repourl), d)
+            fetch_cmd = "%s fetch -f --prune %s refs/*:refs/*" % (ud.basecmd, repourl)
+            bb.fetch2.check_network_access(d, fetch_cmd, ud.url)
+            runfetchcmd(fetch_cmd, d)
+            runfetchcmd("%s prune-packed" % ud.basecmd, d)
+            runfetchcmd("%s pack-redundant --all | xargs -r rm" % ud.basecmd, d)
+            ud.repochanged = True
+
+    def build_mirror_data(self, url, ud, d):
+        # Generate a mirror tarball if needed
+        if ud.write_tarballs and (ud.repochanged or not os.path.exists(ud.fullmirror)):
+            os.chdir(ud.clonedir)
+            logger.info("Creating tarball of git repository")
+            runfetchcmd("tar -czf %s %s" % (ud.fullmirror, os.path.join(".") ), d)
+
+    def unpack(self, ud, destdir, d):
+        """ unpack the downloaded src to destdir"""
+
+        subdir = ud.parm.get("subpath", "")
+        if subdir != "":
+            readpathspec = ":%s" % (subdir)
+            def_destsuffix = "%s/" % os.path.basename(subdir)
+        else:
+            readpathspec = ""
+            def_destsuffix = "git/"
+
+        destsuffix = ud.parm.get("destsuffix", def_destsuffix)
+        destdir = os.path.join(destdir, destsuffix)
+        if os.path.exists(destdir):
+            bb.utils.prunedir(destdir)
+
+        runfetchcmd("git clone -s -n %s/ %s" % (ud.clonedir, destdir), d)
+        if not ud.nocheckout:
+            os.chdir(destdir)
+            if subdir != "":
+                runfetchcmd("%s read-tree %s%s" % (ud.basecmd, ud.revisions[ud.names[0]], readpathspec), d)
+                runfetchcmd("%s checkout-index -q -f -a" % ud.basecmd, d)
+            else:
+                runfetchcmd("%s checkout %s" % (ud.basecmd, ud.revisions[ud.names[0]]), d)
+        return True
+
+    def clean(self, ud, d):
+        """ clean the git directory """
+
+        bb.utils.remove(ud.localpath, True)
+        bb.utils.remove(ud.fullmirror)
+
+    def supports_srcrev(self):
+        return True
+
+    def _contains_ref(self, tag, d):
+        basecmd = data.getVar("FETCHCMD_git", d, True) or "git"
+        cmd = "%s log --pretty=oneline -n 1 %s -- 2> /dev/null | wc -l" % (basecmd, tag)
+        output = runfetchcmd(cmd, d, quiet=True)
+        if len(output.split()) > 1:
+            raise bb.fetch2.FetchError("The command '%s' gave output with more then 1 line unexpectedly, output: '%s'" % (cmd, output))
+        return output.split()[0] != "0"
+
+    def _revision_key(self, url, ud, d, name):
+        """
+        Return a unique key for the url
+        """
+        return "git:" + ud.host + ud.path.replace('/', '.') + ud.branches[name]
+
+    def _latest_revision(self, url, ud, d, name):
+        """
+        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.branches[name])
+        bb.fetch2.check_network_access(d, cmd)
+        output = runfetchcmd(cmd, d, True)
+        if not output:
+            raise bb.fetch2.FetchError("The command %s gave empty output unexpectedly" % cmd, url)
+        return output.split()[0]
+
+    def _build_revision(self, url, ud, d, name):
+        return ud.revisions[name]
+
+    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):
+            logger.debug(1, "GIT repository for %s does not exist in %s.  \
+                          Downloading.", url, ud.clonedir)
+            self.download(None, ud, d)
+            if not os.path.exists(ud.clonedir):
+                logger.error("GIT repository for %s does not exist in %s after \
+                             download. Cannot get sortable buildnumber, using \
+                             old value", url, ud.clonedir)
+                return None
+
+
+        os.chdir(ud.clonedir)
+        if not self._contains_ref(rev, d):
+            self.download(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]
+        logger.debug(1, "GIT repository for %s in %s is returning %s revisions in rev-list before %s", url, ud.clonedir, buildindex, rev)
+        return buildindex
+
+    def checkstatus(self, uri, ud, d):
+        fetchcmd = "%s ls-remote %s" % (ud.basecmd, uri)
+        try:
+            runfetchcmd(fetchcmd, d, quiet=True)
+            return True
+        except FetchError:
+            return False
--- a/bitbake/lib/bb/fetch2/hg.py
+++ b/bitbake/lib/bb/fetch2/hg.py
@@ -0,0 +1,176 @@
+# 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 logging
+import bb
+from bb import data
+from bb.fetch2 import FetchMethod
+from bb.fetch2 import FetchError
+from bb.fetch2 import MissingParameterError
+from bb.fetch2 import runfetchcmd
+from bb.fetch2 import logger
+
+class Hg(FetchMethod):
+    """Class to fetch 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 urldata_init(self, ud, d):
+        """
+        init hg specific variable within url data
+        """
+        if not "module" in ud.parm:
+            raise MissingParameterError('module', ud.url)
+
+        ud.module = ud.parm["module"]
+
+        # Create paths to mercurial checkouts
+        relpath = self._strip_leading_slashes(ud.path)
+        ud.pkgdir = os.path.join(data.expand('${HGDIR}', d), ud.host, relpath)
+        ud.moddir = os.path.join(ud.pkgdir, ud.module)
+
+        ud.setup_revisons(d)
+
+        if 'rev' in ud.parm:
+            ud.revision = ud.parm['rev']
+        elif not ud.revision:
+            ud.revision = self.latest_revision(ud.url, ud, d)
+
+        ud.localfile = data.expand('%s_%s_%s_%s.tar.gz' % (ud.module.replace('/', '.'), ud.host, ud.path.replace('/', '.'), ud.revision), d)
+
+    def need_update(self, url, ud, d):
+        revTag = ud.parm.get('rev', 'tip')
+        if revTag == "tip":
+            return True
+        if not os.path.exists(ud.localpath):
+            return True
+        return False
+
+    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 = ud.parm.get('proto', 'http')
+
+        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 == "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 == "fetch":
+            cmd = "%s clone %s %s://%s/%s %s" % (basecmd, " ".join(options), proto, hgroot, ud.module, ud.module)
+        elif command == "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 == "update":
+            cmd = "%s update -C %s" % (basecmd, " ".join(options))
+        else:
+            raise FetchError("Invalid hg command %s" % command, ud.url)
+
+        return cmd
+
+    def download(self, loc, ud, d):
+        """Fetch url"""
+
+        logger.debug(2, "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")
+            logger.info("Update " + loc)
+            # update sources there
+            os.chdir(ud.moddir)
+            logger.debug(1, "Running %s", updatecmd)
+            bb.fetch2.check_network_access(d, updatecmd, ud.url)
+            runfetchcmd(updatecmd, d)
+
+        else:
+            fetchcmd = self._buildhgcommand(ud, d, "fetch")
+            logger.info("Fetch " + loc)
+            # check out sources there
+            bb.utils.mkdirhier(ud.pkgdir)
+            os.chdir(ud.pkgdir)
+            logger.debug(1, "Running %s", fetchcmd)
+            bb.fetch2.check_network_access(d, fetchcmd, ud.url)
+            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")
+        os.chdir(ud.moddir)
+        logger.debug(1, "Running %s", updatecmd)
+        runfetchcmd(updatecmd, d)
+
+        scmdata = ud.parm.get("scmdata", "")
+        if scmdata == "keep":
+            tar_flags = ""
+        else:
+            tar_flags = "--exclude '.hg' --exclude '.hgrags'"
+
+        os.chdir(ud.pkgdir)
+        runfetchcmd("tar %s -czf %s %s" % (tar_flags, ud.localpath, ud.module), d, cleanup = [ud.localpath])
+
+    def supports_srcrev(self):
+        return True
+
+    def _latest_revision(self, url, ud, d, name):
+        """
+        Compute tip revision for the url
+        """
+        bb.fetch2.check_network_access(d, self._buildhgcommand(ud, d, "info"))
+        output = runfetchcmd(self._buildhgcommand(ud, d, "info"), d)
+        return output.strip()
+
+    def _build_revision(self, url, ud, d, name):
+        return ud.revision
+
+    def _revision_key(self, url, ud, d, name):
+        """
+        Return a unique key for the url
+        """
+        return "hg:" + ud.moddir
--- a/bitbake/lib/bb/fetch2/local.py
+++ b/bitbake/lib/bb/fetch2/local.py
@@ -0,0 +1,91 @@
+# ex:ts=4:sw=4:sts=4:et
+# -*- tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*-
+"""
+BitBake 'Fetch' implementations
+
+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.
+#
+# Based on functions from the base bb module, Copyright 2003 Holger Schurig
+
+import os
+import bb
+import bb.utils
+from   bb import data
+from   bb.fetch2 import FetchMethod
+
+class Local(FetchMethod):
+    def supports(self, url, urldata, d):
+        """
+        Check to see if a given url represents a local fetch.
+        """
+        return urldata.type in ['file']
+
+    def urldata_init(self, ud, d):
+        # We don't set localfile as for this fetcher the file is already local!
+        ud.basename = os.path.basename(ud.url.split("://")[1].split(";")[0])
+        return
+
+    def localpath(self, url, urldata, d):
+        """
+        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, True)
+            if filespath:
+                newpath = bb.utils.which(filespath, path)
+            if not newpath:
+                filesdir = data.getVar('FILESDIR', d, True)
+                if filesdir:
+                    newpath = os.path.join(filesdir, path)
+        if not os.path.exists(newpath) and path.find("*") == -1:
+            dldirfile = os.path.join(data.getVar("DL_DIR", d, True), os.path.basename(path))
+            return dldirfile
+        return newpath
+
+    def need_update(self, url, ud, d):
+        if url.find("*") != -1:
+            return False
+        if os.path.exists(ud.localpath):
+            return False
+        return True
+
+    def download(self, url, urldata, d):
+        """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:
+            logger.info("URL %s looks like a glob and was therefore not checked.", url)
+            return True
+        if os.path.exists(urldata.localpath):
+            return True
+        return False
+
+    def clean(self, urldata, d):
+        return
+
--- a/bitbake/lib/bb/fetch2/osc.py
+++ b/bitbake/lib/bb/fetch2/osc.py
@@ -0,0 +1,135 @@
+# 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 logging
+import  bb
+from    bb       import data
+from    bb.fetch2 import FetchMethod
+from    bb.fetch2 import FetchError
+from    bb.fetch2 import MissingParameterError
+from    bb.fetch2 import runfetchcmd
+
+class Osc(FetchMethod):
+    """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 urldata_init(self, ud, d):
+        if not "module" in ud.parm:
+            raise MissingParameterError('module', ud.url)
+
+        ud.module = ud.parm["module"]
+
+        # Create paths to osc checkouts
+        relpath = self._strip_leading_slashes(ud.path)
+        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 = bb.fetch2.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)
+
+    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 = ud.parm.get('proto', 'ocs')
+
+        options = []
+
+        config = "-c %s" % self.generate_config(ud, d)
+
+        if ud.revision:
+            options.append("-r %s" % ud.revision)
+
+        coroot = self._strip_leading_slashes(ud.path)
+
+        if command == "fetch":
+            osccmd = "%s %s co %s/%s %s" % (basecmd, config, coroot, ud.module, " ".join(options))
+        elif command == "update":
+            osccmd = "%s %s up %s" % (basecmd, config, " ".join(options))
+        else:
+            raise FetchError("Invalid osc command %s" % command, ud.url)
+
+        return osccmd
+
+    def download(self, loc, ud, d):
+        """
+        Fetch url
+        """
+
+        logger.debug(2, "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")
+            logger.info("Update "+ loc)
+            # update sources there
+            os.chdir(ud.moddir)
+            logger.debug(1, "Running %s", oscupdatecmd)
+            bb.fetch2.check_network_access(d, oscupdatecmd, ud.url)
+            runfetchcmd(oscupdatecmd, d)
+        else:
+            oscfetchcmd = self._buildosccommand(ud, d, "fetch")
+            logger.info("Fetch " + loc)
+            # check out sources there
+            bb.utils.mkdirhier(ud.pkgdir)
+            os.chdir(ud.pkgdir)
+            logger.debug(1, "Running %s", oscfetchcmd)
+            bb.fetch2.check_network_access(d, oscfetchcmd, ud.url)
+            runfetchcmd(oscfetchcmd, d)
+
+        os.chdir(os.path.join(ud.pkgdir + ud.path))
+        # tar them up to a defined filename
+        runfetchcmd("tar -czf %s %s" % (ud.localpath, ud.module), d, cleanup = [ud.localpath])
+
+    def supports_srcrev(self):
+        return False
+
+    def generate_config(self, ud, d):
+        """
+        Generate a .oscrc to be used for this run.
+        """
+
+        config_path = os.path.join(data.expand('${OSCDIR}', d), "oscrc")
+        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/Show More
+++ b/Show More