--- a/GNUmakefile	Sun Apr 29 13:09:16 2007 +0200
+++ b/GNUmakefile	Sun Apr 29 23:28:01 2007 +0200
@@ -1,4 +1,4 @@
-sources = GNUmakefile $(wildcard *.make *.py specs/*.py lib/*.py)
+sources = GNUmakefile $(filter-out %~, $(wildcard *.make bin/* gub/*.py gub/specs/*.py gub/specs/cross/*.py))
 
 default: compilers
 

--- a/bin/cygwin-packager	Sun Apr 29 13:09:16 2007 +0200
+++ b/bin/cygwin-packager	Sun Apr 29 23:28:01 2007 +0200
@@ -25,14 +25,12 @@
 import optparse
 import os
 import sys
-
-sys.path.insert (0, 'lib/')
-
-import context
-import gup
-import settings as settings_mod
-import misc
-import cygwin
+#
+from gub import context
+from gub import gup
+import gub.settings
+from gub import misc
+from gub import cygwin
 
 class Cygwin_package (context.Os_context_wrapper):
     def __init__ (self, settings, name, branch):
@@ -325,7 +323,7 @@
 def main ():
     (options, commands)  = parse_command_line ()
     platform = 'cygwin'
-    settings = settings_mod.get_settings (platform)
+    settings = gub.settings.get_settings (platform)
     # We want to be able to specify a build number for cygwin packages
     # that are not distributed on lp.org
     settings.build = options.build

--- a/bin/gpkg	Sun Apr 29 13:09:16 2007 +0200
+++ b/bin/gpkg	Sun Apr 29 23:28:01 2007 +0200
@@ -27,9 +27,7 @@
 import re
 import string
 import sys
-
-sys.path.insert (0, 'lib/')
-
+#
 import gup
 import oslog
 

--- a/bin/gub	Sun Apr 29 13:09:16 2007 +0200
+++ b/bin/gub	Sun Apr 29 23:28:01 2007 +0200
@@ -24,17 +24,14 @@
 import re
 import string
 import sys
-
-sys.path.insert (0, 'lib/')
-
-import cross
-
+#
+from gub import cross
 ## fixme: double use of gub name.
-import gub
-import gup
-import misc
-import settings as settings_mod
-import locker
+from gub import gubb
+from gub import misc
+import gub.settings
+from gub import locker
+from gub import gup
 
 def get_cli_parser ():
     import optparse
@@ -61,7 +58,7 @@
                   type='choice',
                   default=None,
                   help='select target platform',
-                  choices=settings_mod.platforms.keys ())
+                  choices=gub.settings.platforms.keys ())
 
     p.add_option ('--inspect', action='store',
                   dest='inspect_key',
@@ -327,7 +324,7 @@
 
     ## UGH -> double work, see cross.change_target_packages () ?
     sdk_pkgs = [p for p in specs.values ()
-                if isinstance (p, gub.SdkBuildSpec)]
+                if isinstance (p, gubb.SdkBuildSpec)]
     cross_pkgs = [p for p in specs.values ()
                   if isinstance (p, cross.CrossToolSpec)]
 
@@ -343,7 +340,7 @@
         
 def get_settings (options):
     # FIXME, move (all these get_setting*) to constructors
-    settings = settings_mod.get_settings (options.platform)
+    settings = gub.settings.get_settings (options.platform)
     settings.set_branches (options.branches)
     settings.build_source = options.build_source
     settings.cpu_count = options.cpu_count

--- a/bin/installer-builder	Sun Apr 29 13:09:16 2007 +0200
+++ b/bin/installer-builder	Sun Apr 29 23:28:01 2007 +0200
@@ -28,11 +28,11 @@
 
 sys.path.insert (0, 'lib/')
 
-import gup
-import installer
-import settings as settings_mod
-import locker
-import versiondb
+from gub import gup
+from gub import installer
+import gub.settings
+from gub import locker
+from gub import versiondb
 
 def parse_command_line ():
     p = optparse.OptionParser ()
@@ -82,7 +82,7 @@
                   type='choice',
                   default=None,
                   help='select target platform',
-                  choices=settings_mod.platforms.keys ())
+                  choices=gub.settings.platforms.keys ())
 
     (options, args) = p.parse_args ()
     
@@ -209,7 +209,7 @@
 def main ():
     (options, commands)  = parse_command_line ()
 
-    settings = settings_mod.get_settings (options.platform)
+    settings = gub.settings.get_settings (options.platform)
 
     settings.set_branches (options.branches)
     for s in options.settings:

--- a/bin/test-gub	Sun Apr 29 13:09:16 2007 +0200
+++ b/bin/test-gub	Sun Apr 29 23:28:01 2007 +0200
@@ -244,7 +244,7 @@
 def real_main (options, args, handle_result):
     global log_file
 
-    log = 'log/test-gub.log'
+    log = 'log/test-gubb.log'
     if options.dry_run:
         log = ''
 

--- a/gub.make	Sun Apr 29 13:09:16 2007 +0200
+++ b/gub.make	Sun Apr 29 23:28:01 2007 +0200
@@ -1,7 +1,7 @@
 CWD:=$(shell pwd)
 PYTHON=python
-PYTHONPATH=lib/
-export PYTHONPATH
+#PYTHONPATH=gub
+#export PYTHONPATH
 
 ## must always have one host.
 GUB_DISTCC_ALLOW_HOSTS=127.0.0.1

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/gub/__init__.py	Sun Apr 29 23:28:01 2007 +0200
@@ -0,0 +1,21 @@
+"""
+    Copyright (c) 2005--2007
+    Jan Nieuwenhuizen <janneke@gnu.org>
+    Han-Wen Nienhuys <hanwen@xs4all.nl>
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2, or (at your option)
+    any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program; if not, write to the Free Software
+    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+"""
+
+"""gub lib"""

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/gub/config_cache.py	Sun Apr 29 23:28:01 2007 +0200
@@ -0,0 +1,272 @@
+config_cache = {
+    'local': '',
+    'all': '''
+
+# FIXME: 32 bit only
+ac_16bit_type=${ac_16bit_type=short}
+ac_32bit_type=${ac_32bit_type=int}
+ac_64bit_type=${ac_64bit_type=none}
+ac_cv_c_long_size_t=${ac_cv_c_long_size_t=no}
+ac_cv_c_long_time_t=${ac_cv_c_long_time_t=yes}
+ac_cv_c_stack_direction=${ac_cv_c_stack_direction=-1}
+ac_cv_func_getpgrp_void=${ac_cv_func_getpgrp_void=yes}
+ac_cv_func_select=${ac_cv_func_select=yes} # but in mingw only if winsock2.h
+ac_cv_func_setvbuf_reversed=${ac_cv_func_setvbuf_reversed=no}
+ac_cv_lib_dld_shl_load=${ac_cv_lib_dld_shl_load=no}
+ac_cv_search_dlopen=${ac_cv_search_dlopen="none required"}
+ac_cv_sizeof___int64=${ac_cv_sizeof___int64=0}
+# FIXME: 32 bit only
+ac_cv_sizeof_char=${ac_cv_sizeof_char=1}
+ac_cv_sizeof_char_p=${ac_cv_sizeof_char_p=4}
+ac_cv_sizeof_double=${ac_cv_sizeof_double=8}
+ac_cv_sizeof_float=${ac_cv_sizeof_float=4}
+ac_cv_sizeof_int=${ac_cv_sizeof_int=4}
+ac_cv_sizeof_intmax_t=${ac_cv_sizeof_intmax_t=8}
+ac_cv_sizeof_intptr_t=${ac_cv_sizeof_intptr_t=4}
+ac_cv_sizeof_long=${ac_cv_sizeof_long=4}
+ac_cv_sizeof_long_double=${ac_cv_sizeof_long_double=12}
+ac_cv_sizeof_long_long=${ac_cv_sizeof_long_long=8}
+ac_cv_sizeof_ptrdiff_t=${ac_cv_sizeof_ptrdiff_t=4}
+ac_cv_sizeof_short=${ac_cv_sizeof_short=2}
+ac_cv_sizeof_size_t=${ac_cv_sizeof_size_t=4}
+ac_cv_sizeof_uintptr_t=${ac_cv_sizeof_uintptr_t=4}
+ac_cv_sizeof_unsigned___int64=${ac_cv_sizeof_unsigned___int64=0}
+ac_cv_sizeof_unsigned_char=${ac_cv_sizeof_unsigned_char=1}
+ac_cv_sizeof_unsigned_int=${ac_cv_sizeof_unsigned_int=4}
+ac_cv_sizeof_unsigned_long=${ac_cv_sizeof_unsigned_long=4}
+ac_cv_sizeof_unsigned_long_long=${ac_cv_sizeof_unsigned_long_long=8}
+ac_cv_sizeof_unsigned_short=${ac_cv_sizeof_unsigned_short=2}
+ac_cv_sizeof_void_p=${ac_cv_sizeof_void_p=4}
+ac_cv_spinlocks=${ac_cv_spinlocks=no}
+ac_cv_sprintf_count=${ac_cv_sprintf_count=yes}
+ac_cv_sys_restartable_syscalls=${ac_cv_sys_restartable_syscalls=yes}
+
+# libtool searches not only in the cross libpath
+#     /cygwin/usr/lib:/cygwin/usr/lib/w32api:/usr/i686-cygwin/lib
+# but also in /usr/lib.  there it finds libdl.a and adds -ldl
+# to LIBS
+# it seems that libtool is broken wrt cross compilation:
+#    sys_lib_search_path_spec="/usr/lib /lib/w32api /lib /usr/local/lib"
+libltdl_cv_sys_search_path=${libltdl_cv_sys_search_path="'"%(system_root)s/usr/lib %(system_root)s/lib"'"}
+
+lt_cv_dlopen=${lt_cv_dlopen="dlopen"}
+''',
+    'arm' : '''
+ac_cv_func_posix_getpwuid_r=${ac_cv_func_posix_getpwuid_r=yes}
+ac_cv_lib_dl_dlopen=${ac_cv_lib_dl_dlopen=yes}
+
+glib_cv_uscore=${glib_cv_uscore=no}
+
+lt_cv_dlopen_libs=${lt_cv_dlopen_libs="-ldl"}
+lt_cv_sys_max_cmd_len=${lt_cv_sys_max_cmd_len=32768}
+##libltdl_cv_sys_search_path=${libltdl_cv_sys_search_path="'"%(system_root)s/usr/lib %(system_root)s/usr/lib"'"}
+libltdl_cv_sys_search_path=${libltdl_cv_sys_search_path="'"%(system_root)s/usr/lib %(system_root)s/lib"'"}
+''',
+    'mipsel' : '''
+ac_cv_func_posix_getpwuid_r=${ac_cv_func_posix_getpwuid_r=yes}
+ac_cv_lib_dl_dlopen=${ac_cv_lib_dl_dlopen=yes}
+
+glib_cv_uscore=${glib_cv_uscore=no}
+
+lt_cv_dlopen_libs=${lt_cv_dlopen_libs="-ldl"}
+lt_cv_sys_max_cmd_len=${lt_cv_sys_max_cmd_len=32768}
+##libltdl_cv_sys_search_path=${libltdl_cv_sys_search_path="'"%(system_root)s/usr/lib %(system_root)s/usr/lib"'"}
+libltdl_cv_sys_search_path=${libltdl_cv_sys_search_path="'"%(system_root)s/usr/lib %(system_root)s/lib"'"}
+''',
+    'freebsd6-x86' : '''
+ac_cv_func_posix_getpwuid_r=${ac_cv_func_posix_getpwuid_r=no}
+ac_cv_lib_dl_dlopen=${ac_cv_lib_dl_dlopen=no}
+
+glib_cv_uscore=${glib_cv_uscore=no}
+
+lt_cv_dlopen_libs=${lt_cv_dlopen_libs="-lc"}
+lt_cv_sys_max_cmd_len=${lt_cv_sys_max_cmd_len=32768}
+##libltdl_cv_sys_search_path=${libltdl_cv_sys_search_path="'"%(system_root)s/usr/lib %(system_root)s/lib "'"}
+libltdl_cv_sys_search_path=${libltdl_cv_sys_search_path="'"%(system_root)s/usr/lib %(system_root)s/lib "'"}
+
+
+ac_cv_file__dev_ptmx=${ac_cv_file__dev_ptmx=no}
+ac_cv_file__dev_ptc=${ac_cv_file__dev_ptc=no}
+
+
+libc_cv_forced_unwind=${libc_cv_forced_unwind=yes}
+libc_cv_c_cleanup=${libc_cv_c_cleanup=yes}
+
+''',
+    'linux-x86' : '''
+ac_cv_func_posix_getpwuid_r=${ac_cv_func_posix_getpwuid_r=yes}
+ac_cv_lib_dl_dlopen=${ac_cv_lib_dl_dlopen=yes}
+
+glib_cv_uscore=${glib_cv_uscore=no}
+
+lt_cv_dlopen_libs=${lt_cv_dlopen_libs="-ldl"}
+lt_cv_sys_max_cmd_len=${lt_cv_sys_max_cmd_len=32768}
+##libltdl_cv_sys_search_path=${libltdl_cv_sys_search_path="'"%(system_root)s/usr/lib %(system_root)s/usr/lib"'"}
+libltdl_cv_sys_search_path=${libltdl_cv_sys_search_path="'"%(system_root)s/usr/lib %(system_root)s/lib"'"}
+
+ac_cv_file__dev_ptmx=${ac_cv_file__dev_ptmx=yes}
+ac_cv_file__dev_ptc=${ac_cv_file__dev_ptc=no}
+
+
+
+''',
+    'linux-64' : """
+# FIXME: clean type lengths from `all' section
+unset ac_16bit_type
+unset ac_32bit_type
+unset ac_64bit_type
+unset ac_cv_c_long_size_t
+unset ac_cv_c_long_time_t
+#
+unset ac_cv_sizeof___int64
+unset ac_cv_sizeof_char
+unset ac_cv_sizeof_char_p
+unset ac_cv_sizeof_double
+unset ac_cv_sizeof_float
+unset ac_cv_sizeof_int
+unset ac_cv_sizeof_intmax_t
+unset ac_cv_sizeof_intptr_t
+unset ac_cv_sizeof_long
+unset ac_cv_sizeof_long_double
+unset ac_cv_sizeof_long_long
+unset ac_cv_sizeof_ptrdiff_t
+unset ac_cv_sizeof_short
+unset ac_cv_sizeof_size_t
+unset ac_cv_sizeof_uintptr_t
+unset ac_cv_sizeof_unsigned___int64
+unset ac_cv_sizeof_unsigned_char
+unset ac_cv_sizeof_unsigned_int
+unset ac_cv_sizeof_unsigned_long
+unset ac_cv_sizeof_unsigned_long_long
+unset ac_cv_sizeof_unsigned_short
+unset ac_cv_sizeof_void_p
+
+
+ac_16bit_type=${ac_16bit_type=short}
+ac_32bit_type=${ac_32bit_type=int}
+ac_64bit_type=${ac_64bit_type=long}
+ac_cv_c_long_size_t=${ac_cv_c_long_size_t=yes}
+ac_cv_c_long_time_t=${ac_cv_c_long_time_t=yes}
+#
+ac_cv_sizeof___int64=${ac_cv_sizeof___int64=0}
+ac_cv_sizeof_char=${ac_cv_sizeof_char=1}
+ac_cv_sizeof_char_p=${ac_cv_sizeof_char_p=8}
+ac_cv_sizeof_double=${ac_cv_sizeof_double=8}
+ac_cv_sizeof_float=${ac_cv_sizeof_float=4}
+ac_cv_sizeof_int=${ac_cv_sizeof_int=4}
+ac_cv_sizeof_intmax_t=${ac_cv_sizeof_intmax_t=8}
+ac_cv_sizeof_intptr_t=${ac_cv_sizeof_intptr_t=8}
+ac_cv_sizeof_long=${ac_cv_sizeof_long=8}
+ac_cv_sizeof_long_double=${ac_cv_sizeof_long_double=16}
+ac_cv_sizeof_long_long=${ac_cv_sizeof_long_long=8}
+ac_cv_sizeof_ptrdiff_t=${ac_cv_sizeof_ptrdiff_t=8}
+ac_cv_sizeof_short=${ac_cv_sizeof_short=2}
+ac_cv_sizeof_size_t=${ac_cv_sizeof_size_t=8}
+ac_cv_sizeof_uintptr_t=${ac_cv_sizeof_uintptr_t=8}
+ac_cv_sizeof_unsigned___int64=${ac_cv_sizeof_unsigned___int64=0}
+ac_cv_sizeof_unsigned_char=${ac_cv_sizeof_unsigned_char=1}
+ac_cv_sizeof_unsigned_int=${ac_cv_sizeof_unsigned_int=4}
+ac_cv_sizeof_unsigned_long=${ac_cv_sizeof_unsigned_long=8}
+ac_cv_sizeof_unsigned_long_long=${ac_cv_sizeof_unsigned_long_long=8}
+ac_cv_sizeof_unsigned_short=${ac_cv_sizeof_unsigned_short=2}
+ac_cv_sizeof_void_p=${ac_cv_sizeof_void_p=8}
+
+ac_cv_func_posix_getpwuid_r=${ac_cv_func_posix_getpwuid_r=yes}
+ac_cv_lib_dl_dlopen=${ac_cv_lib_dl_dlopen=yes}
+
+glib_cv_uscore=${glib_cv_uscore=no}
+
+lt_cv_dlopen_libs=${lt_cv_dlopen_libs="-ldl"}
+lt_cv_sys_max_cmd_len=${lt_cv_sys_max_cmd_len=32768}
+##libltdl_cv_sys_search_path=${libltdl_cv_sys_search_path="'"%(system_root)s/usr/lib %(system_root)s/usr/lib"'"}
+libltdl_cv_sys_search_path=${libltdl_cv_sys_search_path="'"%(system_root)s/usr/lib %(system_root)s/lib"'"}
+
+ac_cv_file__dev_ptmx=${ac_cv_file__dev_ptmx=yes}
+ac_cv_file__dev_ptc=${ac_cv_file__dev_ptc=no}
+
+""",
+    'darwin-ppc' : '''
+ac_cv_c_bigendian=${ac_cv_c_bigendian=yes}
+ac_cv_func_posix_getpwuid_r=${ac_cv_func_posix_getpwuid_r=yes}
+ac_cv_type_socklen_t=${ac_cv_type_socklen_t=yes}
+
+glib_cv_uscore=${glib_cv_uscore=no}
+
+lt_cv_dlopen_libs=${lt_cv_dlopen_libs="none required"}
+lt_cv_sys_max_cmd_len=${lt_cv_sys_max_cmd_len=8192}
+
+ac_cv_file__dev_ptc=${ac_cv_file__dev_ptc=no}
+ac_cv_file__dev_ptmx=${ac_cv_file__dev_ptmx=no}
+
+
+''',
+    'linux-ppc' : '''
+ac_cv_func_posix_getpwuid_r=${ac_cv_func_posix_getpwuid_r=yes}
+ac_cv_lib_dl_dlopen=${ac_cv_lib_dl_dlopen=yes}
+
+glib_cv_uscore=${glib_cv_uscore=no}
+
+lt_cv_dlopen_libs=${lt_cv_dlopen_libs="-ldl"}
+lt_cv_sys_max_cmd_len=${lt_cv_sys_max_cmd_len=32768}
+##libltdl_cv_sys_search_path=${libltdl_cv_sys_search_path="'"%(system_root)s/usr/lib %(system_root)s/usr/lib"'"}
+libltdl_cv_sys_search_path=${libltdl_cv_sys_search_path="'"%(system_root)s/usr/lib %(system_root)s/lib"'"}
+ac_cv_c_bigendian=${ac_cv_c_bigendian=yes}
+
+ac_cv_file__dev_ptmx=${ac_cv_file__dev_ptmx=yes}
+ac_cv_file__dev_ptc=${ac_cv_file__dev_ptc=no}
+
+''',
+
+    'darwin-x86' : '''
+ac_cv_c_bigendian=${ac_cv_c_bigendian=no}
+ac_cv_func_posix_getpwuid_r=${ac_cv_func_posix_getpwuid_r=yes}
+ac_cv_type_socklen_t=${ac_cv_type_socklen_t=yes}
+
+glib_cv_uscore=${glib_cv_uscore=no}
+
+lt_cv_dlopen_libs=${lt_cv_dlopen_libs="none required"}
+lt_cv_sys_max_cmd_len=${lt_cv_sys_max_cmd_len=8192}
+
+ac_cv_file__dev_ptc=${ac_cv_file__dev_ptc=no}
+ac_cv_file__dev_ptmx=${ac_cv_file__dev_ptmx=no}
+''',
+
+    ## check me: ac_cv_file__dev_ptmx
+    'cygwin': '''
+ac_cv_func_mkfifo=${ac_cv_func_mkfifo=yes}
+ac_cv_have_dev_ptc=${ac_cv_have_dev_ptc=}
+ac_cv_have_dev_ptmx=${ac_cv_have_dev_ptmx=}
+ac_cv_lib_dl_dlopen=${ac_cv_lib_dl_dlopen=no}
+ac_cv_file__dev_ptmx=${ac_cv_file__dev_ptmx=no}
+ac_cv_file__dev_ptc=${ac_cv_file__dev_ptc=no}
+
+lt_cv_dlopen_libs=${lt_cv_dlopen_libs="none required"}
+lt_cv_sys_max_cmd_len=${lt_cv_sys_max_cmd_len=8192}
+libltdl_cv_sys_search_path=${libltdl_cv_sys_search_path="'"%(system_root)s/usr/lib %(system_root)s/usr/lib/w32api %(system_root)s/lib"'"}
+''',
+    'mingw': '''
+ac_cv_func_malloc_0_nonnull=${ac_cv_func_malloc_0_nonnull=yes}
+ac_cv_func_memcmp_working=${ac_cv_func_memcmp_working=yes}
+ac_cv_func_mkfifo=${ac_cv_func_mkfifo=no}
+ac_cv_func_stat_empty_string_bug=${ac_cv_func_stat_empty_string_bug=no}
+ac_cv_have_dev_ptc=${ac_cv_have_dev_ptc=no}
+ac_cv_have_dev_ptmx=${ac_cv_have_dev_ptmx=no}
+ac_cv_file__dev_ptmx=${ac_cv_file__dev_ptmx=no}
+ac_cv_file__dev_ptc=${ac_cv_file__dev_ptc=no}
+ac_cv_lib_dl_dlopen=${ac_cv_lib_dl_dlopen=no}
+ac_cv_exeext=${ac_cv_exeext=.exe}
+ac_exeext=${ac_exeext=}
+ac_cv_type_struct_sockaddr_storage=${ac_cv_type_struct_sockaddr_storage=yes}
+ac_cv_c_c99_format=${ac_cv_c_c99_format=no}
+lt_cv_dlopen_libs=${lt_cv_dlopen_libs="none required"}
+lt_cv_sys_max_cmd_len=${lt_cv_sys_max_cmd_len=8192}
+libltdl_cv_sys_search_path=${libltdl_cv_sys_search_path="'"%(system_root)s/usr/lib %(system_root)s/usr/lib/w32api %(system_root)s/lib"'"}
+'''
+}
+
+config_cache['debian'] = config_cache['linux-x86']
+config_cache['debian-arm'] = config_cache['arm']
+config_cache['linux-arm-softfloat'] = config_cache['arm']
+config_cache['linux-arm-vfp'] = config_cache['arm']
+config_cache['freebsd-x86'] = config_cache['freebsd6-x86']
+config_cache['freebsd4-x86'] = config_cache['freebsd6-x86']

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/gub/context.py	Sun Apr 29 23:28:01 2007 +0200
@@ -0,0 +1,222 @@
+import inspect
+import os
+import re
+import fnmatch
+
+def subst_method (func):
+    """Decorator to match Context.get_substitution_dict()"""
+    
+    func.substitute_me = True
+    return func
+
+def is_subst_method_in_class (method_name, klass):
+    bs = [k for k in klass.__bases__
+          if is_subst_method_in_class (method_name, k)]
+    if bs:
+        return True
+    
+    if (klass.__dict__.has_key (method_name)
+      and callable (klass.__dict__[method_name])
+      and klass.__dict__[method_name].__dict__.has_key ('substitute_me')):
+        return True
+
+    return False
+
+def typecheck_substitution_dict (d):
+    for (k, v) in d.items ():
+        if type (v) != type(''):
+            raise Exception ('type', (k, v))
+
+def recurse_substitutions (d):
+    for (k, v) in d.items ():
+        if type(v) != type(''):
+            del d[k]
+            continue
+
+        try:
+            while v.index ('%(') >= 0:
+                v = v % d
+        except ValueError:
+            pass
+        d[k] = v
+
+    return d
+
+class ConstantCall:
+    def __init__ (self, const):
+        self.const = const
+    def __call__ (self):
+        return self.const
+    
+class Context:
+    def __init__ (self, parent = None):
+        self._substitution_dict = None
+        self._parent = parent
+
+    def get_constant_substitution_dict (self):
+        d = {}
+        if self._parent:
+            d = self._parent.get_substitution_dict ()
+            d = d.copy ()
+            
+        ms = inspect.getmembers (self)
+        vars = dict((k, v) for (k, v) in ms if type (v) == type (''))
+
+        member_substs = {}
+        for (name, method) in ms:
+            try:
+                ccall = self.__dict__[name]
+                if isinstance (ccall, ConstantCall):
+                    method = ccall
+            except KeyError:
+                pass
+            
+            if (callable (method)
+                and is_subst_method_in_class (name, self.__class__)):
+                
+                val = method ()
+                self.__dict__[name] = ConstantCall (val)
+
+                member_substs[name] = val
+
+                if type (val) != type (''):
+                    print 'non string value ', val, 'for subst_method', name
+                    raise Exception
+        
+        d.update (vars)
+        d.update (member_substs)
+
+        d = recurse_substitutions (d)
+        return d
+
+    def get_substitution_dict (self, env={}):
+        if  self._substitution_dict == None:
+            self._substitution_dict = self.get_constant_substitution_dict ()
+
+        d = self._substitution_dict
+        if env:
+            d = d.copy ()
+            for (k, v) in env.items ():
+                try:
+                    if type (v) == type (''):
+                        d.update ({k: v % d})
+                except:
+                    print 'error substituting in', v
+                    print 'with', k
+                    raise 
+        return d
+    
+    def expand (self, s, env={}):
+        d = self.get_substitution_dict (env)
+        try:
+            e = s % d
+        except KeyError, v:
+            print 's=', s
+            raise v
+        except ValueError, v:
+            print 's=', s
+            raise v
+        return e
+
+class Os_context_wrapper (Context):
+    def __init__ (self, settings):
+        Context.__init__ (self, settings)
+        self.os_interface = settings.os_interface
+        self.verbose = settings.verbose ()
+        
+    def file_sub (self, re_pairs, name, to_name=None, env={}, must_succeed=False, use_re=True):
+        substs = []
+        for (frm, to) in re_pairs:
+            frm = self.expand (frm, env)
+            if type (to) ==type(''):
+                to = self.expand (to, env)
+
+            substs.append ((frm, to))
+
+        if to_name:
+            to_name = self.expand (to_name, env)
+            
+        return self.os_interface.file_sub (substs, self.expand (name, env), to_name, must_succeed, use_re=use_re)
+    
+    def log_command (self, str, env={}):
+        str = self.expand (str, env)
+        self.os_interface.log_command (str)
+        
+    def read_pipe (self, cmd, env={}, ignore_errors=False):
+        dict = self.get_substitution_dict (env)
+        return self.os_interface.read_pipe (cmd % dict, ignore_errors=ignore_errors)
+
+    def system (self, cmd, env={}, ignore_errors=False):
+        dict = self.get_substitution_dict (env)
+        cmd = self.expand (cmd, env)
+        self.os_interface.system (cmd, env=dict, ignore_errors=ignore_errors,
+                                  verbose=self.verbose)
+
+    def shadow_tree (self, src, dest):
+        src = self.expand (src)
+        dest = self.expand (dest)
+        self.os_interface.shadow_tree (src, dest)
+        
+    def dump (self, str, name, mode='w', env={},
+              expand_string=True, expand_name=True):
+        if expand_name:
+            name = self.expand (name, env)
+        if expand_string:
+            str = self.expand (str, env)
+            
+        return self.os_interface.dump (str, name, mode=mode)
+    
+    def locate_files (self, directory, pattern,
+                      include_dirs=True, include_files=True):
+        """
+        Find file using glob PATTERNs. DIRECTORY is expanded.
+
+        Results include DIRECTORY in the filenames.
+        """
+
+        ## find() is actually not portable across unices,
+        ## so we bake our own.
+        
+        directory = self.expand (directory)
+        directory = re.sub ( "/*$", '/', directory)
+        
+        results = []
+        for (root, dirs, files) in os.walk (directory):
+            relative_results = []
+            if include_dirs:
+                relative_results += dirs
+            if include_files:
+                relative_results += files
+                
+            results += [os.path.join (root, f)
+                        for f in (fnmatch.filter (relative_results, pattern))]
+
+        return results
+
+#
+# Tests.
+#
+if __name__=='__main__':
+    class TestBase(Context):
+        @subst_method
+        def bladir(self):
+            return 'foo'
+        
+    class TestClass(TestBase):
+        @subst_method
+        def name(self):
+            return self.__class__.__name__
+        
+        def bladir(self):
+            return 'derivedbladir'
+    class S: 
+        pass
+    
+    p = TestClass ()
+    from gub import settings
+    s = settings.Settings ('debian-arm')
+    c = Os_context_wrapper (s)
+
+    print c.locate_files ('/etc/', '*.conf')
+    
+    print p.expand ('%(name)s %(bladir)s')

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/gub/cross.py	Sun Apr 29 23:28:01 2007 +0200
@@ -0,0 +1,183 @@
+import os
+#
+from gub import gubb
+from gub import misc
+
+from context import subst_method 
+class CrossToolSpec (gubb.BuildSpec):
+    """Package for cross compilers/linkers etc.
+    """
+
+    def configure_command (self):
+        return (gubb.BuildSpec.configure_command (self)
+            + misc.join_lines ('''
+--program-prefix=%(target_architecture)s-
+--prefix=%(cross_prefix)s
+--with-slibdir=/usr/lib
+--target=%(target_architecture)s
+--with-sysroot=%(system_root)s
+--disable-multilib
+'''))
+
+    def compile_command (self):
+        return self.native_compile_command ()
+        
+    def install_command (self):
+        return '''make DESTDIR=%(install_root)s prefix=/usr/cross install'''
+
+#    def gub_src_uploads (self):
+#        return '%(gub_cross_uploads)s'
+
+    def get_subpackage_names (self):
+        return ['doc', '']
+    
+    def license_file (self):
+        return ''
+
+#FIXME: merge fully with specs/binutils.py
+class Binutils (CrossToolSpec):
+    def install (self):
+        CrossToolSpec.install (self)
+        self.system ('rm %(install_root)s/usr/cross/lib/libiberty.a')
+    
+#FIXME: merge fully with specs/gcc
+class Gcc (CrossToolSpec):
+    def get_build_dependencies (self):
+        return ['cross/binutils']
+
+    @subst_method
+    def NM_FOR_TARGET(self):
+         return '%(tool_prefix)snm'
+
+    def get_subpackage_names (self):
+        # FIXME: why no -devel package?
+        return ['doc', 'runtime', '']
+
+    def languages (self):
+        return  ['c', 'c++']
+        
+    def configure_command (self):
+        cmd = CrossToolSpec.configure_command (self)
+        # FIXME: using --prefix=%(tooldir)s makes this
+        # uninstallable as a normal system package in
+        # /usr/i686-mingw/
+        # Probably --prefix=/usr is fine too
+
+        language_opt = (' --enable-languages=%s '
+                        % ','.join (self.languages ()))
+        cxx_opt = '--enable-libstdcxx-debug '
+
+        cmd += '''
+--with-as=%(cross_prefix)s/bin/%(target_architecture)s-as
+--with-ld=%(cross_prefix)s/bin/%(target_architecture)s-ld
+--enable-static
+--enable-shared '''
+
+        cmd += language_opt
+        if 'c++' in self.languages ():
+            cmd +=  ' ' + cxx_opt
+
+        return misc.join_lines (cmd)
+
+    def move_target_libs (self, libdir):
+        if not os.path.isdir (libdir):
+            return
+
+        files = []
+
+        ## .so* because version numbers trail .so extension. 
+        for suf in ['.la', '.so*', '.dylib']:
+            files += self.locate_files (libdir, 'lib*' + suf)
+            
+        for f in files:
+            (dir, file) = os.path.split (f)
+            target = self.expand ('%(install_prefix)s/%(dir)s', locals ())
+            if not os.path.isdir (target):
+                os.makedirs (target)
+            self.system ('mv %(f)s %(install_prefix)s/lib', locals ())
+
+    def install (self):
+        CrossToolSpec.install (self)
+        old_libs = self.expand ('%(install_root)s/usr/cross/%(target_architecture)s')
+
+        self.move_target_libs (old_libs)
+        self.move_target_libs (self.expand ('%(install_root)s/usr/cross/lib'))
+        if os.path.exists (self.expand ('cd %(install_root)s/usr/lib/libgcc_s.so.1')):
+            # FIXME: .so senseless for darwin.
+            self.system ('''
+cd %(install_root)s/usr/lib && ln -fs libgcc_s.so.1 libgcc_s.so
+''')
+
+def change_target_package (package):
+    pass
+
+def set_cross_dependencies (package_object_dict):
+    packs = package_object_dict.values ()
+    cross_packs = [p for p in packs if isinstance (p, CrossToolSpec)]
+    sdk_packs = [p for p in packs if isinstance (p, gubb.SdkBuildSpec)]
+    other_packs = [p for p in packs if (not isinstance (p, CrossToolSpec)
+                                        and not isinstance (p, gubb.SdkBuildSpec)
+                                        and not isinstance (p, gubb.BinarySpec))]
+    
+    sdk_names = [s.name() for s in sdk_packs]
+    cross_names = [s.name() for s in cross_packs]
+    for p in other_packs:
+        old_callback = p.get_build_dependencies
+        p.get_build_dependencies = misc.MethodOverrider (old_callback,
+                                                         lambda x,y: x+y, (cross_names,))
+
+    for p in other_packs + cross_packs:
+        old_callback = p.get_build_dependencies
+        p.get_build_dependencies = misc.MethodOverrider (old_callback,
+                                                         lambda x,y: x+y, (sdk_names,))
+
+    return packs
+
+cross_module_checksums = {}
+cross_module_cache = {}
+def get_cross_module (platform):
+    base = platform
+    try:
+        base = {
+            'darwin-ppc':'darwintools',
+            'darwin-x86':'darwintools',
+            'freebsd-x86': 'freebsd',
+            'freebsd4-x86': 'freebsd',
+            'freebsd6-x86': 'freebsd',
+            'linux-ppc' : 'linux',
+            'linux-x86' : 'linux',
+            'linux-64' : 'linux',
+            'local':'tools'}[platform]
+    except KeyError:
+        pass
+
+    if cross_module_cache.has_key (platform):
+        return cross_module_cache[platform]
+    
+    desc = ('.py', 'U', 1)
+    # FIXME: absolute path, should resolve in some way
+    file_name = 'gub/%s.py' % base
+    file = open (file_name)
+    print 'module-name: ' + file_name
+    import imp
+    module = imp.load_module (base, file, file_name, desc)
+
+    import md5
+    cross_module_checksums[platform] = md5.md5 (open (file_name).read ()).hexdigest ()
+    cross_module_cache[platform] = module
+    return module
+
+def get_cross_packages (settings):
+    mod = get_cross_module (settings.platform)
+    return mod.get_cross_packages (settings)
+
+def get_build_dependencies (settings):
+    mod = get_cross_module (settings.platform)
+    return mod.get_cross_build_dependencies (settings)
+
+def get_cross_checksum (platform):
+    try:
+        return cross_module_checksums[platform]
+    except KeyError:
+        print 'No cross module found'
+        return '0000'

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/gub/cygwin.py	Sun Apr 29 23:28:01 2007 +0200
@@ -0,0 +1,381 @@
+import os
+import re
+
+from new import classobj
+from new import instancemethod
+#
+from gub import cross
+from gub import mirrors
+from gub import gubb
+#from gub import gup
+from gub import mingw
+from gub import misc
+
+# FIXME: setting binutil's tooldir and/or gcc's gcc_tooldir may fix
+# -luser32 (ie -L .../w32api/) problem without having to set LDFLAGS.
+class Binutils (cross.Binutils):
+    def makeflags (self):
+        return misc.join_lines ('''
+tooldir="%(cross_prefix)s/%(target_architecture)s"
+''')
+    def compile_command (self):
+        return (cross.Binutils.compile_command (self)
+                + self.makeflags ())
+    def configure_command (self):
+        return ( cross.Binutils.configure_command (self)
+                 + ' --disable-werror ')
+
+class W32api_in_usr_lib (gubb.BinarySpec, gubb.SdkBuildSpec):
+    def get_build_dependencies (self):
+        return ['w32api']
+
+    def install (self):
+        self.system ('mkdir -p %(install_root)s/usr/lib')
+        self.system ('''
+tar -C %(system_root)s/usr/lib/w32api -cf- . | tar -C %(install_root)s/usr/lib -xf-
+''')
+
+class Libtool_fixup (gubb.NullBuildSpec):
+    def get_build_dependencies (self):
+        return ['libtool']
+    def untar (self):
+        self.file_sub ([('/usr/bin/sed', '/bin/sed')],
+                       '%(system_root)s/usr/bin/libtool')
+
+class Gcc (mingw.Gcc):
+    def get_build_dependencies (self):
+        return (mingw.Gcc.get_build_dependencies (self)
+                + ['cygwin', 'w32api-in-usr-lib'])
+    def makeflags (self):
+        return misc.join_lines ('''
+tooldir="%(cross_prefix)s/%(target_architecture)s"
+gcc_tooldir="%(cross_prefix)s/%(target_architecture)s"
+''')
+    def compile_command (self):
+        return (mingw.Gcc.compile_command (self)
+                + self.makeflags ())
+
+    def configure_command (self):
+        return (mingw.Gcc.configure_command (self)
+                + misc.join_lines ('''
+--with-newlib
+--enable-threads
+'''))
+
+
+def untar_cygwin_src_package_variant2 (self, file_name, split=False):
+    '''Unpack this unbelievably broken version of Cygwin source packages.
+
+foo[version][-split]-x.y.z-b.tar.bz2 contains
+foo[-split]-x.y.z.tar.[bz2|gz] and foo[version]-x.y.z-b.patch
+(and optionally foo[version]-x.y.z-b.patch2 ...).
+foo-x.y.z.tar.[bz2|gz] contains foo-x.y.z.  The patch contains patches
+against all foo split source balls, so applying it may fail partly and
+complain about missing files.'''
+
+    file_name = self.expand (file_name)
+    from gub import misc
+    t = misc.split_ball (file_name)
+    print 'split: ' + `t`
+    no_src = re.sub ('-src', '', file_name)
+    base = re.sub ('\.tar\..*', '', no_src)
+    # FIXME: use split iso custom ball_re macramee
+    ball_re = '^([a-z]+)([.0-9]+)?(-[a-z+]+)?(.*)(-[0-9]+)'
+    m = re.match (ball_re, base)
+    if m.group (3):
+        second_tarball = re.sub (ball_re, '\\1\\3\\4', base)
+    else:
+        second_tarball = re.sub (ball_re, '\\1\\4', base)
+    print 'second_tarball: ' + second_tarball
+    if split and m.group (3):
+        second_tarball_contents = re.sub (ball_re, '\\1\\3\\4', base)
+    else:
+        second_tarball_contents = re.sub (ball_re, '\\1\\4', base)
+    print 'second_tarball_contents: ' + second_tarball_contents
+    flags = '-jxf'
+    self.system ('''
+rm -rf %(allsrcdir)s/%(base)s
+tar -C %(allsrcdir)s %(flags)s %(downloads)s/%(file_name)s
+''',
+                 locals ())
+    tgz = 'tar.bz2'
+    if not os.path.exists (self.expand ('%s(allsrcdir)s/%(second_tarball)s.%(tgz)s',
+                                        locals ())):
+        flags = '-zxf'
+        tgz = 'tar.gz'
+    self.system ('''
+tar -C %(allsrcdir)s %(flags)s %(allsrcdir)s/%(second_tarball)s.%(tgz)s
+''',
+                 locals ())
+    if split:
+        return
+    if m.group (2):
+        patch = re.sub (ball_re, '\\1\\2\\4\\5.patch', base)
+    else:
+        patch = re.sub (ball_re, '\\1\\4\\5.patch', base)
+    print 'patch: ' + patch
+    self.system ('''
+cd %(allsrcdir)s && mv %(second_tarball_contents)s %(base)s
+cd %(srcdir)s && patch -p1 -f < %(allsrcdir)s/%(patch)s || true
+''',
+                 locals ())
+
+class Gcc_core (Gcc):
+    def untar (self):
+        gxx_file_name = re.sub ('-core', '-g++',
+                                self.expand (self.file_name ()))
+        untar_cygwin_src_package_variant2 (self, gxx_file_name, split=True)
+        untar_cygwin_src_package_variant2 (self, self.file_name ())
+
+# download-only package
+class Gcc_gxx (gubb.NullBuildSpec):
+    pass
+
+mirror = 'http://mirrors.kernel.org/sourceware/cygwin'
+def get_cross_packages (settings):
+    from gub import linux
+    cross_packs = [
+        Binutils (settings).with (version='2.17', format='bz2', mirror=mirrors.gnu),
+        W32api_in_usr_lib (settings).with (version='1.0',  strip_components=0),
+        Gcc (settings).with (version='4.1.1', mirror=mirrors.gcc_41, format='bz2'),
+        linux.Freetype_config (settings).with (version='2.1.9'),
+        linux.Python_config (settings).with (version='2.4.3'),
+# FIXME: using the binary libtool package is quite involved, it has
+# names of tools hardcoded and wrong (LD, NM, SED, GCC, GREP, ...)
+#        Libtool_fixup (settings).with (version='1.0'),
+        ]
+    return cross_packs
+
+def change_target_package (package):
+    cross.change_target_package (package)
+    package.get_build_dependencies \
+            = misc.MethodOverrider (package.get_build_dependencies,
+                                    lambda d, extra: d + extra, (['cygwin'],))
+
+    def cyg_defs (d):
+        k = 'runtime'
+        if not d.has_key (k):
+            k = ''
+        d[k].append ('/usr/bin/cyg*dll')
+        d[k].append ('/etc/postinstall')
+        return d
+
+    package.get_subpackage_definitions \
+        = misc.MethodOverrider (package.get_subpackage_definitions, cyg_defs)
+
+    def enable_static (d):
+        return d.replace ('--disable-static', '--enable-static')
+
+    package.configure_command \
+        = misc.MethodOverrider (package.configure_command, enable_static)
+
+    def install (whatsthis, lst):
+	package = lst[0]
+        package.post_install_smurf_exe ()
+        package.install_readmes ()
+
+    package.install \
+        = misc.MethodOverrider (package.install, install, ([package],))
+
+    ## TODO : get_dependency_dict
+        
+    # FIXME: why do cross packages get here too?
+    if isinstance (package, cross.CrossToolSpec):
+        return package
+        
+    gubb.change_target_dict (package, {
+            'DLLTOOL': '%(tool_prefix)sdlltool',
+            'DLLWRAP': '%(tool_prefix)sdllwrap',
+            'LDFLAGS': '-L%(system_root)s/usr/lib -L%(system_root)s/usr/bin -L%(system_root)s/usr/lib/w32api',
+            })
+
+def get_cygwin_package (settings, name, dict, skip):
+    cross = [
+        'base-passwd', 'bintutils',
+        'gcc', 'gcc-core', 'gcc-g++',
+        'gcc-mingw', 'gcc-mingw-core', 'gcc-mingw-g++',
+        'gcc-runtime', 'gcc-core-runtime',
+        ]
+    cycle = ['base-passwd']
+    # FIXME: These packages are not needed for [cross] building,
+    # but most should stay as distro's final install dependency.
+    unneeded = [
+        'autoconf', 'autoconf2.13', 'autoconf2.50', 'autoconf2.5',
+        'automake', 'automake1.9',
+        'ghostscript-base', 'ghostscript-x11',
+        '-update-info-dir',
+        'libguile12', 'libguile16',
+        'libxft', 'libxft1', 'libxft2',
+        'libbz2-1',
+        'perl',
+        'tcltk',
+        'x-startup-scripts',
+        'xorg-x11-bin-lndir',
+        'xorg-x11-etc',
+        'xorg-x11-fnts',
+        'xorg-x11-libs-data',
+        ]
+    blacklist = cross + cycle + skip + unneeded
+    if name in blacklist:
+        name += '::blacklisted'
+    package_class = classobj (name, (gubb.BinarySpec,), {})
+    package = package_class (settings)
+    package.name_dependencies = []
+    if dict.has_key ('requires'):
+        deps = re.sub ('\([^\)]*\)', '', dict['requires']).split ()
+        deps = [x.strip ().lower ().replace ('_', '-') for x in deps]
+
+        deps = filter (lambda x: x not in blacklist, deps)
+        package.name_dependencies = deps
+
+    def get_build_dependencies (self):
+        return self.name_dependencies
+    package.get_build_dependencies = instancemethod (get_build_dependencies,
+                                                     package, package_class)
+    package.ball_version = dict['version']
+    package.url = (mirror + '/' + dict['install'].split ()[0])
+    package.format = 'bz2'
+    from gub import repository
+    package.vc_repository = repository.TarBall (settings.downloads,
+                                                package.url,
+                                                package.ball_version,
+                                                strip_components=0)
+    return package
+
+## UGH.   should split into parsing  package_file and generating gub specs.
+def get_cygwin_packages (settings, package_file, skip=[]):
+    dist = 'curr'
+
+    dists = {'test': [], 'curr': [], 'prev' : []}
+    chunks = open (package_file).read ().split ('\n\n@ ')
+    for i in chunks[1:]:
+        lines = i.split ('\n')
+        name = lines[0].strip ()
+        name = name.lower ()
+        packages = dists['curr']
+        records = {
+            'sdesc': name,
+            'version': '0-0',
+            'install': 'urg 0 0',
+            }
+        j = 1
+        while j < len (lines) and lines[j].strip ():
+            if lines[j][0] == '#':
+                j = j + 1
+                continue
+            elif lines[j][0] == '[':
+                packages.append (get_cygwin_package (settings, name,
+                                                     records.copy (),
+                                                     skip))
+                packages = dists[lines[j][1:5]]
+                j = j + 1
+                continue
+
+            try:
+                key, value = [x.strip () for x in lines[j].split (': ', 1)]
+            except:
+                print lines[j], package_file
+                raise 'URG'
+            if (value.startswith ('"')
+              and value.find ('"', 1) == -1):
+                while 1:
+                    j = j + 1
+                    value += '\n' + lines[j]
+                    if lines[j].find ('"') != -1:
+                        break
+            records[key] = value
+            j = j + 1
+        packages.append (get_cygwin_package (settings, name, records, skip))
+
+    # debug
+    names = [p.name () for p in dists[dist]]
+    names.sort ()
+    return dists[dist]
+
+# FIXME: this really sucks, should translate or something
+# There also is the problem that gub build-dependencies
+# use unsplit packages.
+guile_source = [
+    'guile',
+    'guile-devel',
+    'libguile17',
+    ]
+fontconfig_source = [
+    'fontconfig',
+    'libfontconfig1',
+    'libfontconfig-devel',
+    'fontconfig-devel',
+    ]
+libtool_source = [
+    'libltdl3',
+    'libtool',
+    'libtool1.5',
+    ]
+
+## FIXME: c&p debian.py
+class Dependency_resolver:
+    def __init__ (self, settings):
+        self.settings = settings
+        self.packages = {}
+        self.source = fontconfig_source + guile_source + libtool_source
+        self.load_packages ()
+        
+    def grok_setup_ini (self, file, skip=[]):
+        for p in get_cygwin_packages (self.settings, file, skip):
+            self.packages[p.name ()] = p
+
+    def load_packages (self):
+        url = mirror + '/setup.ini'
+
+        # FIXME: download/offline update
+        file = self.settings.downloads + '/setup.ini'
+        if not os.path.exists (file):
+            misc.download_url (url, self.settings.downloads)
+            # arg
+            # self.file_sub ([('\':"', "':'")], file)
+            s = open (file).read ()
+            open (file, 'w').write (s.replace ('\':"', "':'"))
+        self.grok_setup_ini (file, self.source)
+
+        # support one extra local setup.ini, that overrides the default
+        local_file = self.settings.uploads + '/cygwin/setup.ini'
+        if os.path.exists (local_file):
+            ## FIXME: using the generated setup.ini to install the
+            ## actual to be distributed cygwin packages with cygwin
+            ## names does not work.
+            ##
+            ## After building gub installs the gub packages, using GUB
+            ## naming.
+            #self.grok_setup_ini (local_file)
+            self.grok_setup_ini (local_file, self.source)
+
+    def get_packages (self):
+        return self.packages
+        
+dependency_resolver = None
+
+def init_dependency_resolver (settings):
+    global dependency_resolver
+    dependency_resolver = Dependency_resolver (settings)
+
+def get_packages ():
+    return dependency_resolver.get_packages ()
+
+gub_to_distro_dict = {
+    'expat-devel': ['expat'],
+    'fontconfig-runtime' : ['libfontconfig1'],
+    'fontconfig-devel' : ['libfontconfig-devel'],
+    'freetype' : ['libfreetype26'],
+    'freetype-devel' : ['libfreetype2-devel'],
+    'gettext' : ['libintl8', 'libintl3'],
+    'gmp-devel': ['gmp'],
+    'guile-runtime' : ['libguile17', 'libguile12'],
+#    'libtool': ['libtool1.5'],
+    'libtool-runtime': ['libltdl3'],
+    'libiconv-devel': ['libiconv2'],
+    'pango': ['pango-runtime'],
+    'python-devel': ['python'],
+    'python-runtime': ['python'],
+    'texlive-devel': ['libkpathsea-devel'],
+    'texlive-runtime': ['libkpathsea4']
+    }

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/gub/darwintools.py	Sun Apr 29 23:28:01 2007 +0200
@@ -0,0 +1,318 @@
+import glob
+import re
+import os
+#
+from gub import misc
+from gub import context
+from gub import cross
+from gub import mirrors
+from gub import gubb
+from gub import repository
+
+darwin_sdk_version = '0.4'
+class Odcctools (cross.CrossToolSpec):
+    def configure (self):
+        cross.CrossToolSpec.configure (self)
+
+        ## remove LD64 support.
+        self.file_sub ([('ld64','')],
+                       self.builddir () + '/Makefile')
+
+## change to sdk package
+class Python (gubb.SdkBuildSpec):
+    def __init__ (self, settings):
+        gubb.NullBuildSpec.__init__ (self, settings)
+        self.version = (lambda: '2.3')
+        self.vc_branch = ''
+        self.format = ''
+        self.has_source = False
+
+    def srcdir (self):
+        return '%(allsrcdir)s/python-darwin'
+
+    def package (self):
+        gubb.BuildSpec.package (self)
+        
+    def install (self):
+        self.system ('mkdir -p %(install_root)s/usr/cross/bin/')
+        self.dump ('''#!/bin/sh
+if test "$1" == "--cflags"; then
+  echo "-I%(system_root)s/System/Library/Frameworks/Python.framework/Versions/%(version)s/include/python%(version)s"
+fi
+if test "$1" == "--ldflags"; then
+  echo ""
+fi
+''', '%(install_root)s/usr/cross/bin/python-config')
+        self.system ('chmod +x %(install_root)s/usr/cross/bin/python-config')
+        
+class Darwin_sdk (gubb.SdkBuildSpec):
+    def patch (self):
+        self.system ('''
+rm %(srcdir)s/usr/lib/libgcc*
+rm %(srcdir)s/usr/lib/libstdc\+\+*
+rm %(srcdir)s/usr/lib/libltdl*
+rm %(srcdir)s/usr/include/ltdl.h
+rm -f %(srcdir)s/usr/lib/gcc/*-apple-darwin*/*/*dylib
+rm -rf %(srcdir)s/usr/lib/gcc
+''')
+
+        ## ugh, need to have gcc/3.3/machine/limits.h
+        ### self.system ('rm -rf %(srcdir)s/usr/include/gcc')
+        ##self.system ('rm -rf %(srcdir)s/usr/include/machine/limits.h')
+
+        ## limits.h symlinks into GCC.
+        
+        pat = self.expand ('%(srcdir)s/usr/lib/*.la')
+        for a in glob.glob (pat):
+            self.file_sub ([(r' (/usr/lib/.*\.la)', r'%(system_root)s\1')], a)
+
+
+class Gcc (cross.Gcc):
+    def patch (self):
+        self.file_sub ([('/usr/bin/libtool', '%(cross_prefix)s/bin/%(target_architecture)s-libtool')],
+                       '%(srcdir)s/gcc/config/darwin.h')
+
+        self.file_sub ([('--strip-underscores', '--strip-underscore')],
+                       "%(srcdir)s/libstdc++-v3/scripts/make_exports.pl")
+
+    def configure_command (self):
+        c = cross.Gcc.configure_command (self)
+#                c = re.sub ('enable-shared', 'disable-shared', c)
+        return c
+    
+
+    def configure (self):
+        cross.Gcc.configure (self)
+
+    def rewire_gcc_libs (self):
+        skip_libs = ['libgcc_s']
+        for l in self.locate_files ("%(install_root)s/usr/lib/", '*.dylib'):
+            found_skips = [s for s in  skip_libs if l.find (s) >= 0]
+            if found_skips:
+                continue
+            
+            id = self.read_pipe ('%(tool_prefix)sotool -L %(l)s', locals ()).split()[1]
+            id = os.path.split (id)[1]
+            self.system ('%(tool_prefix)sinstall_name_tool -id /usr/lib/%(id)s %(l)s', locals ())
+        
+    def install (self):
+        cross.Gcc.install (self)
+        self.rewire_gcc_libs ()
+
+    def get_build_dependencies (self):
+        return ['odcctools']
+    
+class Gcc__darwin (Gcc):
+    def configure (self):
+        cross.Gcc.configure (self)
+
+    def install (self):
+        ## UGH ?
+        ## Gcc.install (self)
+
+        cross.Gcc.install (self)
+        self.rewire_gcc_libs ()
+        
+class Rewirer (context.Os_context_wrapper):
+    def __init__ (self, settings):
+        context.Os_context_wrapper.__init__ (self,settings)
+        self.ignore_libs = None
+
+    def get_libaries (self, name):
+        lib_str = self.read_pipe ('''
+%(cross_prefix)s/bin/%(target_architecture)s-otool -L %(name)s
+''',
+                     locals (), ignore_errors=True)
+
+        libs = []
+        for l in lib_str.split ('\n'):
+            m = re.search (r"\s+(.*) \(.*\)", l)
+            if not m:
+                continue
+            if self.ignore_libs.has_key (m.group (1)):
+                continue
+
+            libs.append (m.group (1))
+
+        return libs
+
+    def rewire_mach_o_object (self, name, substitutions):
+        if not substitutions:
+            return
+        changes = ' '.join (['-change %s %s' % (o, d)
+                  for (o, d) in substitutions])
+        self.system ('''
+%(cross_prefix)s/bin/%(target_architecture)s-install_name_tool %(changes)s %(name)s ''',
+              locals ())
+
+    def rewire_mach_o_object_executable_path (self, name):
+        orig_libs = ['/usr/lib']
+
+        libs = self.get_libaries (name)
+        subs = []
+        for l in libs:
+
+            ## ignore self.
+            print os.path.split (l)[1], os.path.split (name)[1]
+            
+            if os.path.split (l)[1] == os.path.split (name)[1]:
+                continue
+            
+            for o in orig_libs:
+                if re.search (o, l):
+                    newpath = re.sub (o, '@executable_path/../lib/', l); 
+                    subs.append ((l, newpath))
+                elif l.find (self.expand ('%(targetdir)s')) >= 0:
+                    print 'found targetdir in linkage', l
+                    raise 'abort'
+
+        self.rewire_mach_o_object (name, subs)
+
+    def rewire_binary_dir (self, dir):
+        if not os.path.isdir (dir):
+            print dir
+            raise 'Not a directory'
+
+        (root, dirs, files) = os.walk (dir).next ()
+        files = [os.path.join (root, f) for f in files]
+
+        skip_libs = ['libgcc_s']
+        for f in files:
+            found_skips = [s for s in  skip_libs if f.find (s) >= 0]
+            if found_skips:
+                continue
+
+            if os.path.isfile (f):
+                self.rewire_mach_o_object_executable_path(f)
+
+    def set_ignore_libs_from_tarball (self, tarball):
+        file_str = self.read_pipe ('tar tzf %(tarball)s', locals())
+        files = file_str.split ('\n')
+        self.set_ignore_libs_from_files (files)
+        
+    def set_ignore_libs_from_files (self, files):
+        self.ignore_libs = dict ((k.strip()[1:], True)
+             for k in files
+             if re.match (r'^\./usr/lib/', k))
+
+    def rewire_root (self, root):
+        if self.ignore_libs == None:
+            raise 'error: should init with file_manager.'
+
+        self.rewire_binary_dir (root + '/usr/lib')
+        for d in glob.glob (root + '/usr/lib/pango/*/modules/'):
+            self.rewire_binary_dir (d)
+
+        self.rewire_binary_dir (root + '/usr/bin')
+
+class Package_rewirer:
+    def __init__ (self, rewirer, package):
+        self.rewirer = rewirer
+        self.package = package
+
+    def rewire (self):
+        self.rewirer.rewire_root (self.package.install_root ())
+
+def get_cross_packages (settings):
+    packages = []
+
+    sdk = Darwin_sdk (settings)
+
+    os_version = 7
+    if settings.platform == 'darwin-x86':
+        os_version = 8
+
+    sdk.vc_repository = repository.TarBall (settings.downloads,
+                                            url='http://lilypond.org/download/gub-sources/darwin%d-sdk-0.4.tar.gz' % os_version,
+                                            version='0.4')
+
+
+    packages.append (sdk)
+    packages.append (Python (settings))
+        
+    packages += [Odcctools (settings).with (version='20060413',
+#    packages += [Odcctools (settings).with (version='20060608',
+                                            mirror=mirrors.opendarwin,
+                                            format='bz2')]
+
+    if settings.target_architecture.startswith ("powerpc"):
+        packages.append (Gcc (settings).with (version='4.1.1',
+                                              mirror=mirrors.gcc_41,
+                                              format='bz2'))
+    else:
+        packages.append (Gcc (settings).with (version='4.2-20070207',
+                                              mirror=mirrors.gcc_snap,
+                                              format='bz2'))
+
+    return packages
+
+def strip_build_dep (old_val, what):
+    deps = old_val
+
+    for w in what:
+        if w in deps:
+            deps.remove (w)
+    deps.sort()
+    return deps                     
+
+    
+def strip_dependency_dict (old_val, what):
+    d = dict((k,[p for p in deps if p not in what])
+             for (k, deps) in old_val.items ())
+
+    return d
+
+def change_target_package (p):
+    cross.change_target_package (p)
+    p.get_build_dependencies = misc.MethodOverrider (p.get_build_dependencies,
+                                                     strip_build_dep, (['zlib', 'zlib-devel'],))
+    p.get_dependency_dict = misc.MethodOverrider (p.get_dependency_dict,
+                                                  strip_dependency_dict, (['zlib', 'zlib-devel'],))
+    gubb.change_target_dict (p, {
+
+            ## We get a lot of /usr/lib/ -> @executable_path/../lib/
+            ## we need enough space in the header to do these relocs.
+            'LDFLAGS': '-Wl,-headerpad_max_install_names ',
+
+            ## UGH: gettext fix for ptrdiff_t
+            'CPPFLAGS' : '-DSTDC_HEADERS',
+            })
+
+        
+def system (c):
+    s = os.system (c)
+    if s:
+        raise 'barf'
+
+def get_darwin_sdk ():
+    def system (s):
+        print s
+        if os.system (s):
+            raise 'barf'
+        
+    host  = 'maagd'
+    version = '0.4'
+    darwin_version  = 8
+
+    dest =        'darwin%(darwin_version)d-sdk-%(version)s' % locals()
+    
+    system ('rm -rf %s' % dest)
+    os.mkdir (dest)
+    
+    src = '/Developer/SDKs/'
+
+    if darwin_version == 7:
+        src += 'MacOSX10.3.9.sdk'
+    else:
+        src += 'MacOSX10.4u.sdk'
+    
+    cmd =  ('rsync -a -v %s:%s/ %s/ ' % (host, src, dest))
+    system (cmd)
+    system ('chmod -R +w %s '  % dest)
+    system ('tar cfz %s.tar.gz %s '  % (dest, dest))
+
+if __name__== '__main__':
+    import sys
+    if len (sys.argv) > 1:
+        get_darwin_sdk ()
+

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/gub/debian-arm.py	Sun Apr 29 23:28:01 2007 +0200
@@ -0,0 +1,35 @@
+import os
+import re
+#
+from gub import cross
+from gub import mirrors
+from gub import gubb
+from gub import linux
+from gub import misc
+from gub import targetpackage
+
+class Debian_arm_runtime (gubb.BinarySpec, gubb.SdkBuildSpec):
+    pass
+
+def get_cross_packages (settings):
+    from gub import debian
+    return debian.get_cross_packages (settings)
+    #return get_cross_packages_pre_eabi (settings)
+
+def get_cross_packages_pre_eabi (settings):
+    binutils_version = '2.16.1'
+    gcc_version = '3.4.3' # only change
+    guile_version = '1.6.7'
+    kernel_version = '2.5.999-test7-bk-17'
+    libc6_version = '2.3.2.ds1-22sarge4'
+    python_version = '2.4.1'
+    from gub import debian
+    return debian._get_cross_packages (settings,
+                                       binutils_version, gcc_version,
+                                       guile_version,
+                                       kernel_version, libc6_version,
+                                       python_version)
+
+def change_target_package (p):
+    cross.change_target_package (p)
+    return p

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/gub/debian.py	Sun Apr 29 23:28:01 2007 +0200
@@ -0,0 +1,301 @@
+import glob
+import os
+import re
+import string
+#
+from gub import cross
+from gub import mirrors
+#from gub import gup
+#import gub.gup as gup
+from gub import gubb
+from gub import linux
+from gub import misc
+from gub import settings
+
+from new import classobj
+from new import instancemethod
+
+mirror = 'http://ftp.de.debian.org/debian'
+
+class Libc6 (gubb.BinarySpec, gubb.SdkBuildSpec):
+    def untar (self):
+        gubb.BinarySpec.untar (self)
+        # Ugh, rewire absolute names and symlinks.
+        i = self.expand ('%(srcdir)s/lib64')
+        if os.path.islink (i):
+            s = os.readlink (i)
+            if s.startswith ('/'):
+                os.remove (i)
+                os.symlink (s[1:], i)
+
+    def patch (self):
+        self.system ('cd %(srcdir)s && rm -rf usr/sbin/ sbin/ bin/ usr/bin')
+
+class Libc6_dev (gubb.BinarySpec, gubb.SdkBuildSpec):
+    def untar (self):
+        gubb.BinarySpec.untar (self)
+        # FIXME: this rewiring breaks ld badly, it says
+        #     i686-linux-ld: cannot find /home/janneke/bzr/gub/target/i686-linux/system/lib/libc.so.6 inside /home/janneke/bzr/gub/target/i686-linux/system/
+        # although that file exists.  Possibly rewiring is not necessary,
+        # but we can only check on non-linux platform.
+        # self.file_sub ([(' /', ' %(system_root)s/')],
+        #               '%(srcdir)s/root/usr/lib/libc.so')
+
+        for i in ('pthread.h', 'bits/sigthread.h'):
+            self.file_sub ([('__thread', '___thread')],
+                           '%(srcdir)s/usr/include/%(i)s',
+                           env=locals ())
+            
+        self.system ('rm -rf  %(srcdir)s/usr/include/asm/  %(srcdir)s/usr/include/linux ')
+            
+class Linux_kernel_headers (gubb.BinarySpec, gubb.SdkBuildSpec):
+    def __init__ (self, settings):
+        gubb.BinarySpec.__init__ (self, settings)
+        self.with (version='2.5.999-test7-bk-17',
+                   strip_components=0,
+                   mirror=mirrors.lilypondorg_deb,
+                   format='deb')
+    def get_subpackage_names (self):
+        return ['']
+
+class Libdbi0_dev (gubb.BinarySpec, gubb.SdkBuildSpec):
+    pass
+
+class Libqt4_dev (gubb.BinarySpec, gubb.SdkBuildSpec):
+    def untar (self):
+        gubb.BinarySpec.untar (self)
+        for i in ('QtCore.pc', 'QtGui.pc', 'QtNetwork.pc'):
+            self.file_sub ([('includedir', 'deepqtincludedir')],
+                           '%(srcdir)s/usr/lib/pkgconfig/%(i)s',
+                           env=locals ())
+
+class Gcc (cross.Gcc):
+    def patch (self):
+        cross.Gcc.patch (self)
+        # KUCH
+        if self.vc_repository._version == '4.1.1':
+            self.system ('''
+cd %(srcdir)s && patch -p1 < %(patchdir)s/gcc-4.1.1-ppc-unwind.patch
+''')
+        # KUCH, KUCH
+        if (self.vc_repository._version == '3.4.3'
+            and self.settings.platform == 'arm'):
+            self.system ('''
+cd %(srcdir)s && patch -p1 < %(patchdir)s/gcc-3.4.3-arm-softvfp-jcn.patch
+''')
+        
+
+    ## TODO: should detect whether libc supports TLS 
+    def configure_command (self):
+        return cross.Gcc.configure_command (self) + ' --disable-tls '
+
+# http://ftp.de.debian.org/debian/pool/main/l/linux-kernel-headers/
+
+def _get_cross_packages (settings,
+                         binutils_version, gcc_version,
+                         guile_version, kernel_version, libc6_version,
+                         python_version):
+    configs = []
+    if not settings.platform.startswith ('linux'):
+        configs = [
+            linux.Guile_config (settings).with (version=guile_version),
+            linux.Python_config (settings).with (version=python_version),
+            ]
+
+    return [
+        Libc6 (settings).with (version=libc6_version, strip_components=0,
+                               mirror=mirrors.lilypondorg_deb, format='deb'),
+        Libc6_dev (settings).with (version=libc6_version, strip_components=0,
+                                   mirror=mirrors.lilypondorg_deb,
+                                   format='deb'),
+        Linux_kernel_headers (settings).with (version=kernel_version,
+                                              strip_components=0,
+                                              mirror=mirrors.lilypondorg_deb,
+                                              format='deb'),
+        
+        cross.Binutils (settings).with (version=binutils_version,
+                                        format='bz2', mirror=mirrors.gnu),
+        Gcc (settings).with (version=gcc_version,
+                             mirror=mirrors.gcc, format='bz2'),
+        ] + configs
+
+# FIXME: determine libc6_version, kernel_version from
+# Packages/Dependency_resolver.
+def get_cross_packages_stable (settings):
+    binutils_version = '2.16.1'
+    gcc_version = '4.1.1'
+    guile_version = '1.6.7'
+    kernel_version = '2.5.999-test7-bk-17'
+    libc6_version = '2.3.2.ds1-22sarge4'
+    python_version = '2.4.1'
+    return _get_cross_packages (settings,
+                                binutils_version, gcc_version,
+                                guile_version, kernel_version, libc6_version,
+                                python_version)
+
+# FIXME: determine libc6_version, kernel_version from
+# Packages/Dependency_resolver.
+def get_cross_packages_unstable (settings):
+    binutils_version = '2.16.1'
+    gcc_version = '4.1.1'
+    guile_version = '1.8.0'
+    kernel_version = '2.6.18-6'
+    libc6_version = '2.3.6.ds1-9'
+    python_version = '2.4.1'
+    return _get_cross_packages (settings,
+                                binutils_version, gcc_version,
+                                guile_version, kernel_version, libc6_version,
+                                python_version)
+
+def get_cross_packages (settings):
+    if settings.debian_branch == 'stable':
+        return get_cross_packages_stable (settings)
+    return get_cross_packages_unstable (settings)
+
+def change_target_package (p):
+    cross.change_target_package (p)
+
+def get_debian_packages (settings, package_file):
+    if settings.verbose:
+        print ('parsing: %s...' % package_file)
+    return map (lambda j: get_debian_package (settings, j),
+          open (package_file).read ().split ('\n\n')[:-1])
+
+def get_debian_package (settings, description):
+    s = description[:description.find ('\nDescription')]
+    d = dict (map (lambda line: line.split (': ', 1),
+           map (string.strip, s.split ('\n'))))
+    # FIXME: should blacklist toplevel gub-builder.py argument iso lilypond
+    blacklist = [
+        'binutils',
+        'cpp',
+        'gcc-3.3',
+        'cpp-3.3',
+        'gcc',
+        'gcc-3.4',
+        'libgcc1',
+        'libgcc1-3.4',
+        'lilypond',
+        'libstdc++6',
+        'libstdc++-dev',
+        'libtool',
+        'perl',
+        'perl-modules',
+        'perl-base',
+#        'pkg-config',
+        ]
+    if d['Package'] in blacklist:
+        d['Package'] += '::blacklisted'
+    package_class = classobj (d['Package'], (gubb.BinarySpec,), {})
+    package = package_class (settings)
+    package.name_dependencies = []
+    if d.has_key ('Depends'):
+        deps = map (string.strip,
+              re.sub ('\([^\)]*\)', '',
+                  d['Depends']).split (', '))
+        # FIXME: BARF, ignore choices
+        deps = filter (lambda x: x.find ('|') == -1, deps)
+        # FIXME: how to handle Provides: ?
+        # FIXME: BARF, fixup libc Provides
+        deps = map (lambda x: re.sub ('libc($|-)', 'libc6\\1', x), deps)
+        deps = map (lambda x: re.sub ('liba52-dev', 'liba52-0.7.4-dev', x), deps)
+        deps = map (lambda x: re.sub ('libpng12-0-dev', 'libpng12-dev', x), deps)
+        # FIXME: ugh, skip some
+        deps = filter (lambda x: x not in blacklist, deps)
+        package.name_dependencies = deps
+
+    def get_build_dependencies (self):
+        return self.name_dependencies
+    package.get_build_dependencies = instancemethod (get_build_dependencies,
+                                                     package, package_class)
+    package.ball_version = d['Version']
+    package.url = mirror + '/' + d['Filename']
+    package.format = 'deb'
+
+    from gub import repository
+    package.vc_repository = repository.TarBall (settings.downloads,
+                                                package.url,
+                                                package.ball_version,
+                                                strip_components=0)
+    return package
+
+## FIXME: c&p cygwin.py
+class Dependency_resolver:
+    def __init__ (self, settings):
+        self.settings = settings
+        self.packages = {}
+        self.load_packages ()
+        
+    def grok_packages_file (self, file):
+        for p in get_debian_packages (self.settings, file):
+            self.package_fixups (p)
+            self.packages[p.name ()] = p
+
+    def package_fixups (self, package):
+        if package.name () == 'libqt4-dev':
+            def untar (whatsthis):
+                gubb.BinarySpec.untar (package)
+                for i in ('QtCore.pc', 'QtGui.pc', 'QtNetwork.pc'):
+                    package.file_sub ([
+                            ('includedir', 'deepqtincludedir'),
+                            ('(-I|-L) */usr',
+                             '''\\1%(system_root)s/usr''' % locals ()),
+                            ],
+                                      '%(srcdir)s/usr/lib/pkgconfig/%(i)s',
+                                      env=locals ())
+            package.untar = misc.MethodOverrider (package.untar, untar)
+
+    def load_packages (self):
+        p = gup.DependencyManager (self.settings.system_root,
+                                   self.settings.os_interface)
+#        arch = settings.platform
+#        if settings.platform == 'debian':
+#            arch = 'i386'
+	arch = self.settings.package_arch
+        branch = self.settings.debian_branch
+        packages_path = '/dists/%(branch)s/main/binary-%(arch)s/Packages.gz' \
+                        % locals ()
+        url = mirror + packages_path
+        base = self.settings.downloads + '/Packages'
+        file = '.'.join ((base, arch, branch))
+
+        # FIXME: download/offline update
+        if not os.path.exists (file):
+            misc.download_url (url, self.settings.downloads)
+            os.system ('gunzip  %(base)s.gz' % locals ())
+            os.system ('mv %(base)s %(file)s' % locals ())
+        self.grok_packages_file (file)
+
+    def get_packages (self):
+        return self.packages
+        
+dependency_resolver = None
+
+def init_dependency_resolver (settings):
+    global dependency_resolver
+    dependency_resolver = Dependency_resolver (settings)
+
+def debian_name_to_dependency_names (name):
+    return dependency_resolver.get_dependencies (name)
+
+def get_packages ():
+    return dependency_resolver.get_packages ()
+
+#FIXME: stable/unstable?
+gub_to_distro_dict = {
+    'fontconfig' : ['libfontconfig1'],
+    'fontconfig-devel' : ['libfontconfig1-dev'],
+    'freetype' : ['libfreetype6'],
+    'freetype-devel' : ['libfreetype6-dev'],
+    'gettext' : ['gettext'],
+    'gettext-devel' : ['gettext'],
+    'gmp-devel': ['libgmp3-dev'],
+    'gmp-runtime': ['libgmp3'],
+    'ghostscript': ['gs'],
+    'guile-runtime' : ['guile-1.6-libs'],
+    'libtool-runtime': ['libltdl3'],
+    'libiconv-devel': ['libiconv2'],
+    'pango': ['libpango1.0-0'],
+    'python-devel': ['python2.4-dev'],
+    'python-runtime': ['python2.4'],
+    }

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/gub/distcc.py	Sun Apr 29 23:28:01 2007 +0200
@@ -0,0 +1,35 @@
+#!/usr/bin/env python
+
+import os
+import re
+import socket
+import sys
+import telnetlib
+
+def live_hosts (hosts, port = 3633):
+    live = []
+    for h in hosts:
+        try:
+            t = telnetlib.Telnet (h, port)
+            t.close ()
+        except socket.error:
+            continue
+
+        live.append ('%s:%d' % (h,port))
+
+    if live:
+        print 'DISTCC live hosts: ', live
+    return live
+
+
+def main ():
+    exe_name = os.path.split (sys.argv[0])[1]
+    path_comps = [c for c in os.environ['PATH'].split (':')
+                  if not re.search ('distcc', c)]
+    os.environ['PATH'] = ':'.join (path_comps)
+    argv = ['distcc', exe_name] + sys.argv[1:]
+    os.execvp ('distcc', argv)
+
+if __name__ == '__main__':
+    main ()
+

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/gub/freebsd.py	Sun Apr 29 23:28:01 2007 +0200
@@ -0,0 +1,73 @@
+import os
+import re
+
+from gub import cross
+from gub import mirrors
+from gub import gubb
+from gub import misc
+from gub import targetpackage
+
+class Binutils (cross.Binutils):
+    def configure_command (self):
+        # Add --program-prefix, otherwise we get
+        # i686-freebsd-FOO iso i686-freebsd4-FOO.
+        return (cross.Binutils.configure_command (self)
+            + misc.join_lines ('''
+--program-prefix=%(tool_prefix)s
+'''))
+
+class Gcc (cross.Gcc):
+    def configure_command (self):
+        # Add --program-prefix, otherwise we get
+        # i686-freebsd-FOO iso i686-freebsd4-FOO.
+        return (cross.Gcc.configure_command (self)
+            + misc.join_lines ('''
+--program-prefix=%(tool_prefix)s
+'''))
+
+class Freebsd_runtime (gubb.BinarySpec, gubb.SdkBuildSpec):
+    def untar (self):
+        gubb.BinarySpec.untar (self)
+    def patch (self):
+        self.system ('rm -rf %(srcdir)s/usr/include/g++')
+
+def _get_cross_packages (settings, libc_version):
+    return (
+        Freebsd_runtime (settings).with (version=libc_version,
+                                         strip_components=0,
+                                         mirror=mirrors.lilypondorg),
+        Binutils (settings).with (version='2.16.1', format='bz2', mirror=mirrors.gnu),
+        Gcc (settings).with (version='4.1.1', mirror=mirrors.gcc_41,
+                             format='bz2'),
+        )
+
+def get_cross_packages_41 (settings):
+    return _get_cross_packages (settings, '4.10-2')
+
+def get_cross_packages_61 (settings):
+    return _get_cross_packages (settings, '6.1-RELEASE')
+
+def get_cross_packages (settings):
+    return get_cross_packages_41 (settings)
+
+    if settings.target_architecture == 'i686-freebsd4':
+        return get_cross_packages_41 (settings)
+    return get_cross_packages_61 (settings)
+
+def change_target_package (package):
+    cross.change_target_package (package)
+
+        
+    
+# FIXME: download from sane place.
+def get_sdk():
+    '''
+
+#FIXME: how to get libc+kernel headers package contents on freebsd?
+# * remove zlib.h, zconf.h or include libz and remove Zlib from src packages?
+# * remove gmp.h, or include libgmp and remove Gmp from src packages?
+# bumb version number by hand, sync with freebsd.py
+freebsd-runtime:
+	ssh xs4all.nl tar -C / --exclude=zlib.h --exclude=zconf.h --exclude=gmp.h -czf public_html/freebsd-runtime-4.10-2.tar.gz /usr/lib/{lib{c,c_r,m}{.a,.so{,.*}},crt{i,n,1}.o} /usr/include
+
+    '''

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/gub/gubb.py	Sun Apr 29 23:28:01 2007 +0200
@@ -0,0 +1,867 @@
+import glob
+import pickle
+import os
+import re
+#
+from gub import misc
+from gub import repository
+from gub.context import *
+
+class PackageSpec:
+    "How to package part of an install_root."
+    
+    def __init__ (self, os_interface):
+        self._dict = {}
+        self._os_interface = os_interface
+        self._file_specs = []
+        self._dependencies = []
+        self._conflicts = []
+        
+    def set_dict (self, dict, sub_name):
+        self._dict = dict.copy ()
+        self._dict['sub_name'] = sub_name
+        if sub_name:
+            sub_name = '-' + sub_name
+        s = ('%(name)s' % dict) + sub_name
+        self._dict['split_name'] = s
+        self._dict['split_ball'] = ('%(gub_uploads)s/%(split_name)s%(ball_suffix)s.%(platform)s.gup') % self._dict
+        self._dict['split_hdr'] = ('%(gub_uploads)s/%(split_name)s%(vc_branch_suffix)s.%(platform)s.hdr') % self._dict
+        self._dict['conflicts_string'] = ';'.join (self._conflicts)
+        self._dict['dependencies_string'] = ';'.join (self._dependencies)
+        self._dict['source_name'] = self.name ()
+        if sub_name:
+            self._dict['source_name'] = self.name ()[:-len (sub_name)]
+        
+    def expand (self, s):
+        return s % self._dict
+    
+    def dump_header_file (self):
+        hdr = self.expand ('%(split_hdr)s')
+        self._os_interface.dump (pickle.dumps (self._dict), hdr)
+        
+    def clean (self):
+        base = self.expand ('%(install_root)s/')
+        for f in self._file_specs:
+            self._os_interface.system ('rm -rf %s%s ' % (base, f))
+
+    def create_tarball (self):
+        cmd = 'tar -C %(install_root)s/%(packaging_suffix_dir)s --ignore-failed --exclude="*~" -zcf %(split_ball)s '
+
+        path = os.path.normpath (self.expand ('%(install_root)s'))
+        globs  = []
+        for f in self._file_specs:
+            f = re.sub ('/+', '/', f)
+            if f.startswith ('/'):
+                f = f[1:]
+                
+            for exp in glob.glob (os.path.join (path, f)):
+                globs.append (exp.replace (path, './').replace ('//', '/'))
+
+        if not globs:
+            globs.append ('thisreallysucks-but-lets-hope-I-dont-exist/')
+            
+        cmd += ' '.join (globs) 
+        cmd = self.expand (cmd)
+        self._os_interface.system (cmd)
+
+    def dict (self):
+        return self._dict
+
+    def name (self):
+        return "%(split_name)s" % self._dict
+    
+class BuildSpec (Os_context_wrapper):
+    def __init__ (self, settings):
+        Os_context_wrapper.__init__(self, settings)
+
+        self.verbose = settings.verbose ()
+        self.settings = settings
+        self.url = ''
+        self.has_source = True
+        self._dependencies = None
+        self._build_dependencies = None
+        
+        self.spec_checksum = '0000' 
+        self.cross_checksum = '0000'
+        
+        # TODO: move to PackageSpec, always instantiate.
+        # then remove all if self.vc_repository checks
+        self.vc_repository = None
+        
+        self.split_packages = []
+        self.so_version = '1'
+
+    @subst_method
+    def LD_PRELOAD (self):
+        return '%(topdir)s/librestrict/librestrict.so'
+    
+    def get_substitution_dict (self, env={}):
+        dict = {
+            'CPATH': '',
+            'CPLUS_INCLUDE_PATH': '',
+            'C_INCLUDE_PATH': '',
+            'LIBRARY_PATH': '/empty-means-cwd-in-feisty',
+            }
+        dict.update (env)
+        d = Os_context_wrapper.get_substitution_dict (self, dict).copy ()
+        return d
+          
+    def class_invoke_version (self, klas, name):
+        name_version = name + '_' + self.version ().replace ('.', '_')
+        if klas.__dict__.has_key (name_version):
+            klas.__dict__[name_version] (self)
+
+    def download (self):
+        if self.vc_repository:
+            self.vc_repository.download ()
+
+    def get_repodir (self):
+        return self.settings.downloads + '/' + self.name ()
+    
+    def get_conflict_dict (self):
+        """subpackage -> list of confict dict."""
+        return {'': [], 'devel': [], 'doc': [], 'runtime': []}
+  
+    def get_dependency_dict (self):
+        """subpackage -> list of dependency dict."""
+        # FIMXE: '' always depends on runtime?
+        return {'': [], 'devel': [], 'doc': [], 'runtime': []}
+  
+    def broken_for_distcc (self):
+        """Set to true if package can't handle make -jX """
+        return False
+    
+    @subst_method
+    def name (self):
+        file = self.__class__.__name__.lower ()
+        file = re.sub ('__.*', '', file)
+        file = re.sub ('_', '-', file)
+
+        ## UGH ? what happens if xx is in a normal name?!
+        file = re.sub ('xx', '++', file)
+        return file
+
+    @subst_method
+    def pretty_name (self):
+        name = self.__class__.__name__
+        name = re.sub ('__.*', '', name)
+        return name
+    
+    @subst_method
+    def file_name (self):
+        if self.url:
+            file = re.sub ('.*/([^/]+)', '\\1', self.url)
+        else:
+            file = self.name ()
+        return file
+
+    @subst_method
+    def source_checksum (self):
+        if self.vc_repository:
+            return self.vc_repository.get_checksum ().replace ('/', '-')
+        
+        return self.version () 
+
+    @subst_method
+    def license_file (self):
+        return '%(srcdir)s/COPYING'
+    
+    @subst_method
+    def basename (self):
+        return misc.ball_basename (self.file_name ())
+
+    @subst_method
+    def packaging_suffix_dir (self):
+        return ''
+
+    @subst_method
+    def full_version (self):
+        return self.version ()
+
+    @subst_method
+    def build_dependencies_string (self):
+        deps = self.get_build_dependencies ()
+        return ';'.join (deps)
+
+    @subst_method
+    def ball_suffix (self):
+        b = '-%(version)s'
+        if self.vc_repository and self.vc_repository.is_tracking ():
+            try:
+                b = '-' + self.vc_repository.branch
+            except AttributeError:
+                pass
+        return b
+
+    @subst_method
+    def vc_branch (self):
+        b = ''
+        if self.vc_repository and self.vc_repository.is_tracking ():
+            try:
+                b = self.vc_repository.branch
+            except AttributeError:
+                pass
+        return b
+    
+    @subst_method
+    def vc_branch_suffix (self):
+        b = ''
+        if self.vc_repository and self.vc_repository.is_tracking ():
+            try:
+                b = '-' + self.vc_repository.branch
+            except AttributeError:
+                pass
+        return b
+        
+    @subst_method
+    def version (self):
+        # kugh, must construct using vc_repository in __init__
+        if not self.vc_repository :
+            print 'need version, but repository not yet set: ', self.name ()
+            raise 'urg'
+        return self.vc_repository.version ()
+
+    @subst_method
+    def name_version (self):
+        return '%s-%s' % (self.name (), self.version ())
+
+    @subst_method
+    def srcdir (self):
+        return '%(allsrcdir)s/%(name)s%(ball_suffix)s'
+
+    @subst_method
+    def builddir (self):
+        return '%(allbuilddir)s/%(name)s%(ball_suffix)s'
+
+    @subst_method
+    def install_root (self):
+        return '%(installdir)s/%(name)s-%(version)s-root'
+
+    @subst_method
+    def install_prefix (self):
+        return self.install_root () + '/usr'
+
+    @subst_method
+    def install_command (self):
+        return '''make DESTDIR=%(install_root)s install'''
+
+    @subst_method
+    def configure_command (self):
+        return '%(srcdir)s/configure --prefix=%(install_prefix)s'
+
+    @subst_method
+    def compile_command (self):
+        return 'make'
+
+    @subst_method
+    def native_compile_command (self):
+        c = 'make'
+
+        job_spec = ' '
+        if self.settings.native_distcc_hosts:
+            job_spec = '-j%d ' % (2*len (self.settings.native_distcc_hosts.split (' ')))
+
+            ## do this a little complicated: we don't want a trace of
+            ## distcc during configure.
+            c = 'DISTCC_HOSTS="%s" %s' % (self.settings.native_distcc_hosts, c)
+            c = 'PATH="%(native_distcc_bindir)s:$PATH" ' + c
+        elif self.settings.cpu_count_str != '1':
+            job_spec += ' -j%s ' % self.settings.cpu_count_str
+
+        c += job_spec
+        return c
+
+
+    @subst_method
+    def src_package_ball (self):
+        return '%(src_package_uploads)s/%(name)s%(ball_suffix)s-src.%(platform)s.tar.gz'
+
+    @subst_method
+    def src_package_uploads (self):
+        return '%(gub_uploads)s'
+
+    @subst_method
+    def stamp_file (self):
+        return '%(statusdir)s/%(name)s-%(version)s-%(source_checksum)s'
+
+    @subst_method
+    def rsync_command (self):
+        return "rsync --exclude .git --exclude _darcs --exclude .svn --exclude CVS -v -a %(downloads)s/%(name)s-%(version)s/ %(srcdir)s"
+
+    def get_stamp_file (self):
+        stamp = self.expand ('%(stamp_file)s')
+        return stamp
+
+    def is_done (self, stage, stage_number):
+        f = self.get_stamp_file ()
+        if os.path.exists (f):
+            return int (open (f).read ()) >= stage_number
+        return False
+
+    def set_done (self, stage, stage_number):
+        open (self.get_stamp_file (),'w'). write ('%d' % stage_number) 
+
+    def autoupdate (self, autodir=0):
+        if not autodir:
+            autodir = self.srcdir ()
+        if os.path.isdir (os.path.join (self.srcdir (), 'ltdl')):
+            self.system ('''
+rm -rf %(autodir)s/libltdl
+cd %(autodir)s && libtoolize --force --copy --automake --ltdl
+''', locals ())
+        else:
+            self.system ('''
+cd %(autodir)s && libtoolize --force --copy --automake
+''', locals ())
+        if os.path.exists (os.path.join (autodir, 'bootstrap')):
+            self.system ('''
+cd %(autodir)s && ./bootstrap
+''', locals ())
+        elif os.path.exists (os.path.join (autodir, 'autogen.sh')):
+
+            ## --noconfigure ??
+            ## is --noconfigure standard for autogen? 
+            self.system ('''
+cd %(autodir)s && bash autogen.sh  --noconfigure
+''', locals ())
+        else:
+            aclocal_opt = ''
+            if os.path.exists (self.expand ('%(system_root)s/usr/share/aclocal')):
+                aclocal_opt = '-I %(system_root)s/usr/share/aclocal'
+                
+            headcmd = ''
+            for c in ('configure.in','configure.ac'):
+                try:
+                    str = open (self.expand ('%(srcdir)s/' + c)).read ()
+                    m = re.search ('A[CM]_CONFIG_HEADER', str)
+                    str = 0   ## don't want to expand str
+                    if m:
+                        headcmd = self.expand ('cd %(autodir)s && autoheader %(aclocal_opt)s', env=locals ())
+                        break
+                    
+                except IOError:
+                    pass
+                
+            self.system ('''
+cd %(autodir)s && aclocal %(aclocal_opt)s
+%(headcmd)s
+cd %(autodir)s && autoconf %(aclocal_opt)s
+''', locals ())
+            if os.path.exists (self.expand ('%(srcdir)s/Makefile.am')):
+                self.system ('''
+cd %(srcdir)s && automake --add-missing --foreign
+''', locals ())
+
+
+    def configure (self):
+        self.system ('''
+mkdir -p %(builddir)s
+cd %(builddir)s && %(configure_command)s
+''')
+
+    def install_license (self):
+        if self.expand ('%(license_file)s'):
+            self.system ('mkdir -p %(install_root)s/license/', ignore_errors=True)
+            self.system ('cp %(license_file)s %(install_root)s/license/%(name)s')
+        
+    def broken_install_command (self):
+        """For packages that do not honor DESTDIR.
+        """
+
+        # FIXME: use sysconfdir=%(install_PREFIX)s/etc?  If
+        # so, must also ./configure that way
+        return misc.join_lines ('''make install
+bindir=%(install_prefix)s/bin
+aclocaldir=%(install_prefix)s/share/aclocal
+datadir=%(install_prefix)s/share
+exec_prefix=%(install_prefix)s
+gcc_tooldir=%(install_prefix)s
+includedir=%(install_prefix)s/include
+infodir=%(install_prefix)s/share/info
+libdir=%(install_prefix)s/lib
+libexecdir=%(install_prefix)s/lib
+mandir=%(install_prefix)s/share/man
+prefix=%(install_prefix)s
+sysconfdir=%(install_prefix)s/etc
+tooldir=%(install_prefix)s
+''')
+
+    def kill_libtool_installation_test (self, file):
+        self.file_sub ([(r'if test "\$inst_prefix_dir" = "\$destdir"; then',
+                         'if false && test "$inst_prefix_dir" = "$destdir"; then')],
+                       file, must_succeed=True)
+        
+    def update_libtool (self):
+        lst = self.locate_files ('%(builddir)s', 'libtool')
+        if lst:
+            new = self.expand ('%(system_root)s/usr/bin/libtool')
+            if not os.path.exists (new):
+                self.log_command ("Cannot update libtool: no such file: %(new)s" % locals ())
+                raise 'barf'
+            for i in lst:
+                self.system ('cp %(new)s %(i)s', locals ())
+                self.kill_libtool_installation_test (i)
+                self.system ('chmod 755  %(i)s', locals ())
+
+    def install (self):
+        self.system ('''
+rm -rf %(install_root)s
+cd %(builddir)s && %(install_command)s
+rm -f %(install_root)s/%(packaging_suffix_dir)s/usr/share/info/dir %(install_root)s/%(packaging_suffix_dir)s/usr/cross/info/dir %(install_root)s/%(packaging_suffix_dir)s/usr/info/dir
+''')
+        self.install_license ()
+        self.libtool_installed_la_fixups ()
+
+    def libtool_installed_la_fixups (self):
+        for la in misc.find (self.expand ('%(install_root)s'), '\.la$'):
+            (dir, base) = os.path.split (la)
+            base = base[3:-3]
+            dir = re.sub (r"^\./", "/", dir)
+            full_la = self.expand ("%(install_root)s/%(la)s", locals())
+
+            self.file_sub ([(''' *-L *[^\"\' ][^\"\' ]*''', ''),
+                    ('''( |=|\')(/[^ ]*usr/lib|%(targetdir)s.*)/lib([^ \'/]*)\.(a|la|so)[^ \']*''',
+                    '\\1-l\\3 '),
+                    ('^old_library=.*',
+                    """old_library='lib%(base)s.a'"""),
+                    ],
+                   full_la, env=locals ())
+            if self.settings.platform.startswith ('mingw'):
+                self.file_sub ([('library_names=.*',
+                                 "library_names='lib%(base)s.dll.a'")],
+                               full_la, env=locals())
+
+    def compile (self):
+        self.system ('cd %(builddir)s && %(compile_command)s')
+
+    # FIXME: should not misusde patch for auto stuff
+    def patch (self):
+        if not os.path.exists ('%(srcdir)s/configure' \
+                               % self.get_substitution_dict ()):
+            self.autoupdate ()
+
+    @subst_method
+    def is_sdk_package (self):
+        return 'false'
+
+    def rewire_symlinks (self):
+        for f in self.locate_files ('%(install_root)s', '*'):
+            if os.path.islink (f):
+                s = os.readlink (f)
+                if s.startswith ('/') and self.settings.system_root not in s:
+
+                    new_dest = os.path.join (self.settings.system_root, s[1:])
+                    os.remove (f)
+                    print 'changing absolute link %s -> %s' % (f, new_dest)
+                    os.symlink (new_dest, f)
+
+    def package (self):
+        self.rewire_symlinks ()
+        
+        ps = self.get_packages ()
+        for p in ps:
+            p.create_tarball ()
+            p.dump_header_file ()
+            p.clean ()
+            
+    def get_build_dependencies (self):
+        return []
+
+    def get_subpackage_definitions (self):
+        d = {
+            'devel': [
+            '/usr/bin/*-config',
+            '/usr/include',
+            '/usr/cross/include',
+            '/usr/share/aclocal',
+            '/usr/lib/lib*.a',
+            '/usr/lib/pkgconfig',
+            ],
+            'doc': [
+            '/usr/share/doc',
+            '/usr/share/gtk-doc',
+            '/usr/share/info',
+            '/usr/share/man',
+            '/usr/cross/info',
+            '/usr/cross/man',
+            ],
+            'runtime': ['/usr/lib', '/usr/share'],
+            '' : ['/'],
+            }
+        return d
+    
+    def get_subpackage_names (self):
+        return ['devel', 'doc', '']
+
+    ## FIXME: patch in via MethodOverride
+    def description_dict (self):
+        return {}
+
+    ## FIXME: patch in via MethodOverride
+    def category_dict (self):
+        return {'': 'interpreters',
+                'runtime': 'libs',
+                'devel': 'devel libs',
+                'doc': 'doc'}
+    
+    def get_packages (self):
+        defs = dict (self.get_subpackage_definitions ())
+
+        ps = []
+
+        conflict_dict = self.get_conflict_dict ()
+        dep_dict = self.get_dependency_dict ()
+        descr_dict = self.description_dict ()
+        category_dict = self.category_dict ()
+        
+        for sub in self.get_subpackage_names ():
+            filespecs = defs[sub]
+            
+            p = PackageSpec (self.os_interface)
+            if sub:
+                p._dependencies = [self.expand ("%(name)s")]
+
+            p._file_specs = filespecs
+            p.set_dict (self.get_substitution_dict (), sub)
+
+            conflict_str = ';'.join (conflict_dict.get (sub, []))
+            if p._dict.has_key ('conflicts_string'):
+                conflict_str = p._dict['conflicts_string'] + ';' + conflict_str
+            p._dict['conflicts_string'] = conflict_str
+
+            dep_str = ';'.join (dep_dict.get (sub, []))
+            if p._dict.has_key ('dependencies_string'):
+                dep_str = p._dict['dependencies_string'] + ';' + dep_str
+            p._dict['dependencies_string'] = dep_str
+
+	    ## FIXME make generic: use cross.get_subpackage_dict_methods () or similar.
+            desc_str = descr_dict.get (sub, '')
+            p._dict['description'] = desc_str
+
+            cat_str = category_dict.get (sub, '')
+            p._dict['category'] = cat_str
+            
+            ps.append (p)
+
+        return ps
+    
+    def src_package (self):
+        # URG: basename may not be source dir name, eg,
+        # package libjpeg uses jpeg-6b.  Better fix at untar
+        # stage?
+        dir_name = re.sub (self.expand ('%(allsrcdir)s/'), '',
+                           self.expand ('%(srcdir)s'))
+        self.system ('''
+tar -C %(allsrcdir)s --exclude "*~" --exclude "*.orig"  -zcf %(src_package_ball)s %(dir_name)s
+''',
+                     locals ())
+
+    def clean (self):
+        self.system ('rm -rf  %(stamp_file)s %(install_root)s', locals ())
+        if self.vc_repository and self.vc_repository.is_tracking ():
+            return
+
+        self.system ('''rm -rf %(srcdir)s %(builddir)s''', locals ())
+
+    def untar (self):
+        if not self.has_source:
+            return False
+        if not (self.vc_repository and self.vc_repository.is_tracking ()) :
+            self.system ('rm -rf %(srcdir)s %(builddir)s %(install_root)s')
+
+        if self.vc_repository:
+            self.vc_repository.update_workdir (self.expand ('%(srcdir)s'))
+            
+        if (os.path.isdir (self.expand ('%(srcdir)s'))):
+            self.system ('chmod -R +w %(srcdir)s', ignore_errors=True)
+
+    def pre_install_smurf_exe (self):
+        for i in self.locate_files ('%(builddir)s', '*.exe'):
+            base = os.path.splitext (i)[0]
+            self.system ('''mv %(i)s %(base)s''', locals ())
+
+    def post_install_smurf_exe (self):
+        for i in (self.locate_files ('%(install_root)s/bin', '*')
+                  + self.locate_files ('%(install_root)s/usr/bin', '*')):
+            if (not os.path.islink (i)
+                and not os.path.splitext (i)[1]
+                and self.read_pipe ('file -b %(i)s', locals ()).startswith ('MS-DOS executable PE')):
+                self.system ('''mv %(i)s %(i)s.exe''', locals ())
+
+    def install_readmes (self):
+        self.system ('''
+mkdir -p %(install_root)s/usr/share/doc/%(name)s
+''')
+        for i in glob.glob ('%(srcdir)s/[A-Z]*'
+                            % self.get_substitution_dict ()):
+            import shutil
+            if (os.path.isfile (i)
+                and not os.path.basename (i).startswith ('Makefile')
+                and not os.path.basename (i).startswith ('GNUmakefile')):
+                shutil.copy2 (i, '%(install_root)s/usr/share/doc/%(name)s'
+                              % self.get_substitution_dict ())
+
+    def build_version (self):
+        "the version in the shipped package."
+        # FIXME: ugly workaround needed for lilypond package...
+        return '%(version)s'
+
+    def build_number (self):
+        # FIXME: actually need the packages' build number here...
+        build_number_file = '%(topdir)s/buildnumber-%(lilypond_branch)s.make'
+        d = misc.grok_sh_variables (self.expand (build_number_file))
+        b = '%(INSTALLER_BUILD)s' % d
+        return b
+
+    # TODO: junk this, always set repo in __init__
+    def with_vc (self, repo):
+        self.vc_repository = repo
+        return self
+
+    def with_tarball (self, mirror='', version='', format='gz', strip_components=1, name=''):
+        return self.with_vc (self.get_tarball (mirror, version, format, strip_components, name))
+
+    def get_tarball (self, mirror, version, format='gz', strip_components=1, name=''):
+        if not name:
+            name = self.name ()
+        if not format:
+            format = self.__dict__.get ('format', 'gz')
+        if not mirror:
+            mirror = self.__dict__.get ('url', '')
+        if not version and self.version:
+            version = self.ball_version
+
+        from gub import repository
+        return repository.NewTarBall (self.settings.downloads, mirror, name, version, format, strip_components)
+
+    # TODO: junk this, use TarBall ()or Version ()
+    def with (self,
+              mirror='',
+              version='',
+              strip_components=1,
+              format='',
+              name=''):
+
+        if not name:
+            name = self.name ()
+        if not format:
+            format = self.__dict__.get ('format', 'gz')
+        if not mirror:
+            mirror = self.__dict__.get ('url', '')
+        if not version and self.version:
+            version = self.ball_version
+
+        self.format = format
+        self.ball_version = version
+        self.url = mirror
+
+        ball_version = version
+        package_arch = self.settings.package_arch
+        if mirror:
+            self.vc_repository = repository.TarBall (self.settings.downloads,
+                                                     # Hmm, better to construct
+                                                     # mirror later?
+                                                     mirror % locals (),
+                                                     version,
+                                                     strip_components=strip_components)
+        else:
+            self.vc_repository = repository.Version (version)
+
+        self.ball_version = version
+
+        ## don't do substitution. We want to postpone
+        ## generating the dict until we're sure it doesn't change.
+
+        return self
+
+class BinarySpec (BuildSpec):
+    def configure (self):
+        pass
+
+    def patch (self):
+        pass
+
+    def compile (self):
+        pass
+
+    def install (self):
+        
+        """Install package into %(install_root). Any overrides should
+        follow this command, since it will erase the old install_root first."""
+        
+        self.system ('mkdir -p %(install_root)s')
+
+        _verbose = ''
+        if self.verbose:
+            _verbose = ' -v'
+        self.system ('tar -C %(srcdir)s -cf- . | tar -C %(install_root)s%(_verbose)s -xf-', env=locals ())
+        self.libtool_installed_la_fixups ()
+
+    def get_subpackage_names (self):
+        # FIXME: splitting makes that cygwin's gettext + -devel subpackage
+        # gets overwritten by cygwin's gettext-devel + '' base package
+        return ['']
+
+    # FIXME: no src packages for binary specs
+    # They used to work, but now they fail?
+    def src_package (self):
+        pass
+
+class NullBuildSpec (BuildSpec):
+    """Placeholder for downloads """
+
+    def compile (self):
+        pass
+    def configure (self):
+        pass
+    def install (self):
+        self.system ('mkdir -p %(install_root)s')
+    def untar (self):
+        pass
+    def patch (self):
+        pass
+    def src_package (self):
+        pass
+
+class SdkBuildSpec (NullBuildSpec):
+    def untar (self):
+        BuildSpec.untar (self)
+
+    def get_subpackage_names (self):
+        return ['']
+    
+    ## UGH: should store superclass names of each package.
+    def is_sdk_package (self):
+        return 'true'
+    
+    def install_root (self):
+        return self.srcdir ()
+
+class Change_target_dict:
+    def __init__ (self, package, override):
+        self._target_dict_method = package.get_substitution_dict
+        self._add_dict = override
+
+    def target_dict (self, env={}):
+        env_copy = env.copy ()
+        env_copy.update (self._add_dict)
+        d = self._target_dict_method (env_copy)
+        return d
+
+    def append_dict (self, env={}):
+        d = self._target_dict_method ()
+        for (k,v) in self._add_dict.items ():
+            d[k] += v
+
+        d.update (env)
+        d = recurse_substitutions (d)
+        return d
+
+def change_target_dict (package, add_dict):
+    """Override the get_substitution_dict() method of PACKAGE."""
+    try:
+        package.get_substitution_dict = Change_target_dict (package, add_dict).target_dict
+    except AttributeError:
+        pass
+
+def append_target_dict (package, add_dict):
+    """Override the get_substitution_dict() method of PACKAGE."""
+    try:
+        package.get_substitution_dict = Change_target_dict (package, add_dict).append_dict
+    except AttributeError:
+        pass
+
+def get_class_from_spec_file (settings, file_name, name):
+    import imp
+
+    print 'reading spec', file_name
+    file = open (file_name)
+    desc = ('.py', 'U', 1)
+    module = imp.load_module (name, file, file_name, desc)
+    # cross/gcc.py:Gcc will be called: cross/Gcc.py,
+    # to distinguish from specs/gcc.py:Gcc.py
+    base = os.path.basename (name)
+    class_name = (base[0].upper () + base[1:]).replace ('-', '_')
+    full = class_name + '__' + settings.platform.replace ('-', '__')
+
+    d = module.__dict__
+    print 'full:', full
+    klass = None
+    while full:
+        if d.has_key (full):
+            klass = d[full]
+            break
+        full = full[:max (full.rfind ('__'), 0)]
+
+#    dropped feature:
+#    version = xxx at toplevel of spec file
+#    mirror = xxx at toplevel of spec file
+#    for i in init_vars.keys ():
+#        if d.has_key (i):
+#            init_vars[i] = d[i]
+
+    print klass.__dict__
+    print klass
+    return klass
+
+def get_build_spec (flavour, settings, url):
+    """
+    Return BuildSpec instance to build package from URL.
+
+    URL can be partly specified (eg: only a name, `lilypond'),
+    defaults are taken from the spec file.
+    """
+    name = url
+    if url.find (':') >= 0:
+        name = os.path.basename (url)
+    init_vars = {'format':None, 'version':None, 'url': None,}
+    if misc.is_ball (name):
+        ball = name
+        name, version_tuple, format = misc.split_ball (ball)
+        version = misc.version_to_string (version_tuple)
+        if not version:
+            name = url
+        elif (url.startswith ('/')
+              or url.startswith ('file://')
+              or url.startswith ('ftp://')
+              or url.startswith ('http://')):
+            init_vars['url'] = url
+        if version:
+            init_vars['version'] = version
+        if format:
+            init_vars['format'] = format
+
+    file_name = settings.specdir + '/' + name + '.py'
+    klass = None
+    checksum = '0000'
+    
+    if os.path.exists (file_name):
+        klass = get_class_from_spec_file (settings, file_name, name)
+        if klass:
+            import md5
+            checksum = md5.md5 (open (file_name).read ()).hexdigest ()
+#   else:
+#       # FIXME: make a --debug-must-have-spec option
+#       ## yes: sucks for cygwin etc. but need this for debugging the rest.
+#       raise Exception ("no such spec: " + url)
+
+    if not klass:
+        print 'NO SPEC for', name
+        from new import classobj
+        # Without explicit spec will only work if URL
+        # includes version and format, eg,
+        # URL=libtool-1.5.22.tar.gz
+        klass = classobj (name, (flavour,), {})
+    package = klass (settings)
+    package.spec_checksum = checksum
+    from gub import cross
+    package.cross_checksum = cross.get_cross_checksum (settings.platform)
+
+    # Initialise building package from url, without spec
+    # test:
+    # bin/gub -p linux-64 ftp://ftp.gnu.org/pub/gnu/bison/bison-2.3.tar.gz
+    if init_vars['version']:
+        package.with (format=init_vars['format'],
+                      mirror=init_vars['url'],
+                      version=init_vars['version'])
+    return package

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/gub/gup.py	Sun Apr 29 23:28:01 2007 +0200
@@ -0,0 +1,497 @@
+import gdbm as dbmodule
+#import dbhash as dbmodule
+
+import pickle
+import os
+import re
+import string
+import fcntl
+import sys
+import glob
+
+#
+from gub.misc import * # FIXME
+
+from gub import cross
+from gub import targetpackage
+from gub import locker
+from gub import gubb ## ugh
+
+class GupException (Exception):
+    pass
+
+class FileManager:
+
+    """FileManager handles a tree, and keeps track of files,
+    associating files with a package name"""
+
+    def __init__ (self, root, os_interface, dbdir=None, clean=False):
+        self.root = os.path.normpath (root)
+        if dbdir:
+            self.config = dbdir
+        else:
+            self.config = self.root + '/etc/gup'
+
+        self.config = os.path.normpath (self.config)
+        self.os_interface = os_interface
+        self.verbose = True
+        self.is_distro = False
+
+        ## lock must be outside of root, otherwise we can't rm -rf root
+        self.lock = locker.Locker (self.root + '.lock')
+        if clean:
+            os_interface.system ('rm -fr %s' % self.config)
+            os_interface.system ('rm -fr %s' % self.root)
+            
+        self.make_dirs ()
+        self._file_package_db = dbmodule.open (self.config
+                           + '/files.db', 'c')
+        self._package_file_db = dbmodule.open (self.config
+                           + '/packages.db', 'c')
+
+    def __repr__ (self):
+        name = self.__class__.__name__
+        root = self.root
+        distro =  self.is_distro
+        return '%(name)s: %(root)s, distro: %(distro)d'  % locals()
+
+    def make_dirs (self):
+        if not os.path.isdir (self.config):
+            self.os_interface.system ('mkdir -p %s' % self.config)
+        if not os.path.isdir (self.root):
+            self.os_interface.system ('mkdir -p %s' % self.root)
+        
+    def tarball_files (self, ball):
+        flag = tar_compression_flag (ball)
+        str = self.os_interface.read_pipe ('tar -t%(flag)sf "%(ball)s"'
+                                           % locals ())
+        lst = str.split ('\n')
+        return lst
+
+    def installed_files (self, package):
+        return self._package_file_db[package].split ('\n')
+
+    def is_installed (self, name):
+        return self._package_file_db.has_key (name)
+
+    def install_tarball (self, ball, name):
+        self.os_interface.log_command ('installing package %(name)s from %(ball)s\n'
+                                       % locals ())
+
+        flag = tar_compression_flag (ball)
+        root = self.root
+        lst = self.tarball_files (ball)
+
+        conflicts = False
+        for f in lst:
+            if (self._file_package_db.has_key (f)
+                and not os.path.isdir (self.root + '/' +  f)):
+                print 'already have file %s: %s' % (f, self._file_package_db[f])
+                conflicts = True
+
+        if conflicts and not self.is_distro:
+            raise Exception ('abort')
+
+        self.os_interface.system ('tar -C %(root)s -x%(flag)sf %(ball)s'
+                                  % locals ())
+
+        self._package_file_db[name] = '\n'.join (lst)
+        for f in lst:
+            # ignore directories.
+            if not f.endswith ('/'):
+                self._file_package_db[f] = name
+            if f.endswith ('.la'):
+                self.libtool_la_fixup (root, f)
+            if f.endswith ('.pc'):
+                self.pkgconfig_pc_fixup (root, f)
+
+    def libtool_la_fixup (self, root, file):
+        # avoid using libs from build platform, by adding
+        # %(system_root)s
+        if file.startswith ('./'):
+            file = file[2:]
+        dir = os.path.dirname (file)
+        self.os_interface.file_sub ([('^libdir=.*',
+                                      """libdir='%(root)s/%(dir)s'""" % locals ()
+                                      ),],
+                                    '%(root)s/%(file)s' % locals ())
+
+    def pkgconfig_pc_fixup (self, root, file):
+        # avoid using libs from build platform, by adding
+        # %(system_root)s
+        if file.startswith ('./'):
+            file = file[2:]
+        dir = os.path.dirname (file)
+        self.os_interface.file_sub ([('(-I|-L) */usr',
+                                      '''\\1%(root)s/usr''' % locals ()
+                                      ),],
+                                    '%(root)s/%(file)s' % locals ())
+
+    def uninstall_package (self, name):
+        self.os_interface.log_command ('uninstalling package: %s\n' % name)
+
+        lst = self.installed_files (name)
+
+        dirs = []
+        files = []
+        for i in lst:
+            f = os.path.join (self.root, i)
+            if os.path.islink (f):
+                files.append (f)
+            elif (not os.path.exists (f)
+               and not self.is_distro):
+                print 'FileManager: uninstall: %s' % name
+                print 'FileManager: no such file: %s' % f
+            elif os.path.isdir (f):
+                dirs.append (f)
+            else:
+                files.append (f)
+
+        for f in files:
+            os.unlink (f)
+
+        for d in reversed (dirs):
+            try:
+                os.rmdir (d)
+            except OSError:
+                print 'warning: %s not empty' % d
+
+        for f in lst:
+
+            ## fixme (?)  -- when is f == ''
+            if not f or f.endswith ('/'):
+                continue
+
+            try:
+                del self._file_package_db[f]
+            except:
+                print 'db delete failing for ', f
+        del self._package_file_db[name]
+
+    def installed_packages (self):
+        names = self._package_file_db.keys ()
+        return names
+
+class PackageDictManager:
+    """
+
+    A dict of PackageName ->  (Key->Value dict)
+
+    which can be read off the disk.
+    """
+    def __init__ (self, os_interface):
+        self._packages = {}
+
+        ## ugh mi 
+        self.verbose = False
+        
+        ## ugh: mi overwrite.
+        self.os_interface = os_interface
+    def register_package_dict (self, d):
+        nm = d['name']
+        if d.has_key ('split_name'):
+            nm = d['split_name']
+        if (self._packages.has_key (nm)):
+            if self._packages[nm]['spec_checksum'] != d['spec_checksum']:
+                self.os_interface.log_command ('******** checksum of %s changed!\n\n' % nm)
+
+            ## UGH ; need to look at installed hdr.
+            if self._packages[nm]['cross_checksum'] != d['cross_checksum']:
+                self.os_interface.log_command ('******** checksum of cross changed for %s\n' % nm)
+            return
+
+        self._packages[nm] = d
+   
+        
+    def register_package_header (self, package_hdr, branch_dict):
+        if self.verbose:
+            self.os_interface.log_command ('reading package header: %s\n'
+                                           % `package_hdr`)
+
+        str = open (package_hdr).read ()
+
+        d = pickle.loads (str)
+
+        if branch_dict.has_key (d['basename']):
+            if branch_dict[d['basename']] != d['vc_branch']:
+                suffix = d['vc_branch']
+                print 'ignoring header: ' + package_hdr
+                branch = branch_dict[d['basename']]
+                print 'branch: %(branch)s, suffix: %(suffix)s' % locals ()
+                return
+        elif d['vc_branch']:
+            sys.stdout.write ('No branch for package %s, ignoring header: %s\n' % (d['basename'], package_hdr))
+            return
+        
+        name = d['split_name']
+        if 0:
+          ## FIXME ?
+          if self._package_dict_db.has_key (name):
+              if str != self._package_dict_db[name]:
+                  self.os_interface.log_command ("package header changed for %s\n" % name)
+
+              return
+
+        self.register_package_dict (d)
+
+    def unregister_package_dict (self, name):
+        del self._packages[name]
+
+    def is_registered (self, package):
+        return self._packages.has_key (package)
+
+    def package_dict (self, package_name):
+        return self._packages[package_name]
+
+    def get_all_packages (self):
+        return self._packages.values ()
+
+    def is_installable (self, name):
+        d = self._packages[name]
+        ball = '%(split_ball)s' % d
+        hdr = '%(split_hdr)s' % d
+        return os.path.exists (ball) and os.path.exists (hdr)
+
+    def read_package_headers (self, s, branch_dict):
+        if os.path.isdir (s) and not s.endswith ('/'):
+            s += '/'
+            
+        for f in glob.glob ('%(s)s*hdr' % locals ()):
+            self.register_package_header (f, branch_dict)
+
+
+## FIXME: MI
+class PackageManager (FileManager, PackageDictManager):
+
+
+    """PackageManager is a FileManager, which also associates a
+    key/value dict with each package.
+
+    Such dicts come either from either 
+
+    1. A build spec (ie. a python object)
+
+    2. A pickled dict on disk, a package header
+
+    3. 
+    """
+
+    
+    def __init__ (self, root, os_interface, **kwargs):
+        FileManager.__init__ (self, root, os_interface, **kwargs)
+        PackageDictManager.__init__ (self, os_interface)
+        
+        self._package_dict_db = dbmodule.open (self.config
+                           + '/dicts.db', 'c')
+        for k in self._package_dict_db.keys ():
+            v = self._package_dict_db[k]
+            self.register_package_dict (pickle.loads (v))
+
+    def installed_package_dicts (self):
+        names = self._package_file_db.keys ()
+        return [self._packages[p] for p in names]
+
+    def install_package (self, name):
+        if self.is_installed (name):
+            return
+        self.os_interface.log_command ('installing package: %s\n'
+                                       % name)
+        if self._package_file_db.has_key (name):
+            print 'already have package ', name
+            raise Exception ('abort')
+        d = self._packages[name]
+        ball = '%(split_ball)s' % d
+        self.install_tarball (ball, name)
+        self._package_dict_db[name] = pickle.dumps (d)
+
+    def uninstall_package (self, name):
+        FileManager.uninstall_package (self, name)
+        del self._package_dict_db[name]
+
+    def source_name (self, name):
+        return self._packages [name]['source_name']
+
+    
+def is_string (x):
+    return type (x) == type ('')
+
+class DependencyManager (PackageManager):
+
+    """Manage packages that have dependencies and
+    build_dependencies in their package dicts"""
+
+    def __init__ (self, root, os_interface, **kwargs):
+        PackageManager.__init__ (self, root, os_interface, **kwargs)
+        self.include_build_deps = True
+
+    def dependencies (self, name):
+        assert is_string (name)
+        try:
+            return self.dict_dependencies (self._packages[name])
+        except KeyError:
+            print 'unknown package', name
+            return []
+
+    def dict_dependencies (self, dict):
+        deps = dict['dependencies_string'].split (';')
+        if self.include_build_deps:
+            deps += dict['build_dependencies_string'].split (';')
+
+        deps = [d for d in deps if d]
+        return deps
+
+
+################
+# UGh moveme
+
+
+def topologically_sorted_one (todo, done, dependency_getter,
+                              recurse_stop_predicate=None):
+    sorted = []
+    if done.has_key (todo):
+        return sorted
+
+    done[todo] = 1
+
+    deps = dependency_getter (todo)
+    for d in deps:
+        if recurse_stop_predicate and recurse_stop_predicate (d):
+            continue
+
+        assert type (d) == type (todo)
+
+        sorted += topologically_sorted_one (d, done, dependency_getter,
+                                            recurse_stop_predicate=recurse_stop_predicate)
+
+    sorted.append (todo)
+    return sorted
+
+def topologically_sorted (todo, done, dependency_getter,
+             recurse_stop_predicate=None):
+    s = []
+    for t in todo:
+        s += topologically_sorted_one (t, done, dependency_getter,
+                                       recurse_stop_predicate)
+
+    return s
+
+
+################################################################
+# UGH
+# this is too hairy. --hwn
+
+def gub_to_distro_deps (deps, gub_to_distro_dict):
+    distro = []
+    for i in deps:
+        if i in gub_to_distro_dict.keys ():
+            distro += gub_to_distro_dict[i]
+        else:
+            distro += [i]
+    return distro
+
+def get_base_package_name (name):
+    name = re.sub ('-devel$', '', name)
+
+    # breaks mingw dep resolution, mingw-runtime
+    ##name = re.sub ('-runtime$', '', name)
+    name = re.sub ('-doc$', '', name)
+    return name
+
+def get_source_packages (settings, todo):
+    """TODO is a list of (source) buildspecs.
+
+Generate a list of BuildSpec needed to build TODO, in
+topological order
+    
+"""
+
+    ## don't confuse callers by not modifying argument
+    todo = todo[:]
+
+    cross_packages = cross.get_cross_packages (settings)
+    spec_dict = dict ((p.name (), p) for p in cross_packages)
+    todo += spec_dict.keys ()
+    if cross_packages:
+        # see linux.py
+        print 'get_cross_packages is deprecated, update to get_build_dependencies.'
+    else:
+        todo += cross.get_build_dependencies (settings)
+
+    def name_to_dependencies_via_gub (name):
+        name = get_base_package_name (name)
+        if spec_dict.has_key (name):
+            spec = spec_dict[name]
+        else:
+            spec = targetpackage.get_build_spec (settings, name)
+            spec_dict[name] = spec
+        return map (get_base_package_name, spec.get_build_dependencies ())
+
+    def name_to_dependencies_via_distro (distro_packages, name):
+        if spec_dict.has_key (name):
+            spec = spec_dict[name]
+        else:
+            if name in todo or name not in distro_packages.keys ():
+                spec = targetpackage.get_build_spec (settings, name)
+            else:
+                spec = distro_packages[name]
+            spec_dict[name] = spec
+        return spec.get_build_dependencies ()
+
+    def name_to_dependencies_via_cygwin (name):
+        return name_to_dependencies_via_distro (cygwin.get_packages (), name)
+
+    def name_to_dependencies_via_debian (name):
+        return name_to_dependencies_via_distro (debian.get_packages (), name)
+
+    name_to_deps = name_to_dependencies_via_gub
+    if settings.platform == 'cygwin':
+        from gub import cygwin
+        cygwin.init_dependency_resolver (settings)
+        name_to_deps = name_to_dependencies_via_cygwin
+    elif settings.platform in ('debian-arm', 'debian', 'mipsel'):
+        from gub import debian
+        debian.init_dependency_resolver (settings)
+        name_to_deps = name_to_dependencies_via_debian
+
+    spec_names = topologically_sorted (todo, {}, name_to_deps)
+    spec_dict = dict ((n, spec_dict[n]) for n in spec_names)
+
+    # Fixup for build from url: spec_dict key is full url,
+    # change to base name
+    for name in spec_dict.keys ():
+        spec = spec_dict[name]
+        if name != spec.name ():
+            spec_dict[spec.name ()] = spec
+
+    cross.set_cross_dependencies (spec_dict)
+
+    if settings.is_distro:
+        def obj_to_dependency_objects (obj):
+            return [spec_dict[n] for n in obj.get_build_dependencies ()]
+    else:
+        def obj_to_dependency_objects (obj):
+            return [spec_dict[get_base_package_name (n)]
+                    for n in obj.get_build_dependencies ()]
+
+    sorted_specs = topologically_sorted (spec_dict.values (), {},
+                                         obj_to_dependency_objects)
+
+    # Make sure we build dependencies in order
+    sorted_names = [o.name () for o in sorted_specs]
+    return (sorted_names, spec_dict)
+
+def get_target_manager (settings):
+    target_manager = DependencyManager (settings.system_root,
+                      settings.os_interface)
+    return target_manager
+
+def add_packages_to_manager (target_manager, settings, package_object_dict):
+    
+    ## Ugh, this sucks: we now have to have all packages
+    ## registered at the same time.
+    
+    for spec in package_object_dict.values ():
+        for package in spec.get_packages ():
+            target_manager.register_package_dict (package.dict ())
+
+    return target_manager