[Boost-commit] svn:boost r47165 - in branches/build/python_port/python/boost/build: build tools tools/types util

From: steven_at_[hidden]
Date: 2008-07-07 00:30:50

Author: steven_watanabe
Date: 2008-07-07 00:30:47 EDT (Mon, 07 Jul 2008)
New Revision: 47165
URL: http://svn.boost.org/trac/boost/changeset/47165

Log:
Port gcc and dependencies.  Hello world builds.  Further functionality is untested
Added:
   branches/build/python_port/python/boost/build/tools/pch.py   (contents, props changed)
   branches/build/python_port/python/boost/build/tools/types/asm.py   (contents, props changed)
Text files modified: 
   branches/build/python_port/python/boost/build/build/generators.py     |    20                                         
   branches/build/python_port/python/boost/build/build/virtual_target.py |     6                                         
   branches/build/python_port/python/boost/build/tools/builtin.py        |   223 +++++++-                                
   branches/build/python_port/python/boost/build/tools/common.py         |    79 +-                                      
   branches/build/python_port/python/boost/build/tools/gcc.py            |  1021 ++++++++++++++++++++++++++++++--------- 
   branches/build/python_port/python/boost/build/tools/rc.py             |     5                                         
   branches/build/python_port/python/boost/build/tools/types/__init__.py |     3                                         
   branches/build/python_port/python/boost/build/tools/unix.py           |     3                                         
   branches/build/python_port/python/boost/build/util/path.py            |    11                                         
   branches/build/python_port/python/boost/build/util/utility.py         |     4                                         
   10 files changed, 1041 insertions(+), 334 deletions(-)

Modified: branches/build/python_port/python/boost/build/build/generators.py
==============================================================================
--- branches/build/python_port/python/boost/build/build/generators.py	(original)
+++ branches/build/python_port/python/boost/build/build/generators.py	2008-07-07 00:30:47 EDT (Mon, 07 Jul 2008)
@@ -93,10 +93,12 @@
         __debug = "--debug-generators" in bjam.variable("ARGV")        
     return __debug
 
-def increase_indent(self):
+def increase_indent():
+    global __indent
     __indent += "    "
 
-def decrease_indent(self):
+def decrease_indent():
+    global __indent
     __indent = __indent[0:-4]
 
 def dout(message):
@@ -137,6 +139,8 @@
             NOTE: all subclasses must have a similar signature for clone to work!
     """
     def __init__ (self, id, composing, source_types, target_types_and_names, requirements):
+        assert(not isinstance(source_types, str))
+        assert(not isinstance(target_types_and_names, str))
         self.id_ = id
         self.composing_ = composing
         self.source_types_ = source_types
@@ -943,19 +947,19 @@
         
     __construct_stack.append (1)
 
-    if project.manager ().logger ().on ():
+    if project.manager().logger().on():
         increase_indent ()
         
-        dout( "*** construct ", target_type, m)
+        dout( "*** construct " + target_type)
         
         for s in sources:
-            dout("    from ", s)
+            dout("    from " + str(s))
 
-        project.manager ().logger ().log (__name__, "    properties: ", prop_set.raw ())
+        project.manager().logger().log (__name__, "    properties: ", prop_set.raw ())
              
-    result = __construct_really (project, name, target_type, prop_set, sources)
+    result = __construct_really(project, name, target_type, prop_set, sources)
 
-    project.manager ().logger ().decrease_indent ()
+    project.manager().logger().decrease_indent()
         
     __construct_stack = __construct_stack [1:]
 

Modified: branches/build/python_port/python/boost/build/build/virtual_target.py
==============================================================================
--- branches/build/python_port/python/boost/build/build/virtual_target.py	(original)
+++ branches/build/python_port/python/boost/build/build/virtual_target.py	2008-07-07 00:30:47 EDT (Mon, 07 Jul 2008)
@@ -842,7 +842,7 @@
         actions which create them.
     """
     def __init__ (self, manager, prop_set):
-        Action.__init__ (self, manager, None, prop_set)
+        Action.__init__ (self, manager, None, None, prop_set)
         
     def actualize (self):
         if not self.actualized_:
@@ -856,7 +856,9 @@
     are not scanned for dependencies."""
 
     def __init__(self, sources, action_name, property_set):
-        Action.__init__(sources, action_name, property_set)
+        #FIXME: should the manager parameter of Action.__init__
+        #be removed? -- Steven Watanabe
+        Action.__init__(boost.build.manager.get_manager(), sources, action_name, property_set)
 
     def actualize_source_type(self, sources, property_set):
         

Modified: branches/build/python_port/python/boost/build/tools/builtin.py
==============================================================================
--- branches/build/python_port/python/boost/build/tools/builtin.py	(original)
+++ branches/build/python_port/python/boost/build/tools/builtin.py	2008-07-07 00:30:47 EDT (Mon, 07 Jul 2008)
@@ -1,3 +1,5 @@
+# Status: minor updates by Steven Watanabe to make gcc work
+#
 #  Copyright (C) Vladimir Prus 2002. Permission to copy, use, modify, sell and
 #  distribute this software is granted provided this copyright notice appears in
 #  all copies. This software is provided "as is" without express or implied
@@ -79,6 +81,31 @@
     feature.extend('variant', [name])
     feature.compose (replace_grist (name, '<variant>'), explicit_properties)
 
+__os_names = """
+    amiga aix bsd cygwin darwin dos emx freebsd hpux iphone linux netbsd
+    openbsd osf qnx qnxnto sgi solaris sun sunos svr4 sysv ultrix unix unixware
+    vms windows
+""".split()
+
+# Translates from bjam current OS to the os tags used in host-os and target-os,
+# i.e. returns the running host-os.
+#
+def default_host_os():
+    host_os = os_name()
+    if host_os not in (x.upper() for x in __os_names):
+        if host_os == 'NT': host_os = 'windows'
+        elif host_os == 'AS400': host_os = 'unix'
+        elif host_os == 'MINGW': host_os = 'windows'
+        elif host_os == 'BSDI': host_os = 'bsd'
+        elif host_os == 'COHERENT': host_os = 'unix'
+        elif host_os == 'DRAGONFLYBSD': host_os = 'bsd'
+        elif host_os == 'IRIX': host_os = 'sgi'
+        elif host_os == 'MACOSX': host_os = 'darwin'
+        elif host_os == 'KFREEBSD': host_os = freebsd
+        elif host_os == 'LINUX': host_os = 'linux'
+        else: host_os = 'unix'
+    return host_os.lower()
+
 def register_globals ():
     """ Registers all features and variants declared by this module.
     """
@@ -88,13 +115,25 @@
     # TODO: check this. Compatibility with bjam names? Subfeature for version?
     os = sys.platform
     feature.feature ('os', [os], ['propagated', 'link-incompatible'])
+
+
+    # The two OS features define a known set of abstract OS names. The host-os is
+    # the OS under which bjam is running. Even though this should really be a fixed
+    # property we need to list all the values to prevent unknown value errors. Both
+    # set the default value to the current OS to account for the default use case of
+    # building on the target OS.
+    feature.feature('host-os', __os_names)
+    feature.set_default('host-os', default_host_os())
+
+    feature.feature('target-os', __os_names, ['propagated', 'link-incompatible'])
+    feature.set_default('target-os', default_host_os())
     
     feature.feature ('toolset', [], ['implicit', 'propagated' ,'symmetric'])
     
     feature.feature ('stdlib', ['native'], ['propagated', 'composite'])
     
     feature.feature ('link', ['shared', 'static'], ['propagated'])
-    feature.feature ('link-runtime', ['shared', 'static'], ['propagated'])
+    feature.feature ('runtime-link', ['shared', 'static'], ['propagated'])
     feature.feature ('runtime-debugging', ['on', 'off'], ['propagated'])
     
     
@@ -136,6 +175,17 @@
     feature.feature ('use', [], ['free', 'dependency', 'incidental'])
     feature.feature ('dependency', [], ['free', 'dependency', 'incidental'])
     feature.feature ('implicit-dependency', [], ['free', 'dependency', 'incidental'])
+
+    feature.feature('warnings', [
+        'on',         # Enable default/"reasonable" warning level for the tool.
+        'all',        # Enable all possible warnings issued by the tool.
+        'off'],       # Disable all warnings issued by the tool.
+        ['incidental', 'propagated'])
+
+    feature.feature('warnings-as-errors', [
+        'off',        # Do not fail the compilation if there are warnings.
+        'on'],        # Fail the compilation if there are warnings.
+        ['incidental', 'propagated'])
     
     feature.feature ('source', [], ['free', 'dependency', 'incidental'])
     feature.feature ('library', [], ['free', 'dependency', 'incidental'])
@@ -170,6 +220,81 @@
     # of the library.
     feature.feature ('allow', [], ['free'])
     
+    # The addressing model to generate code for. Currently a limited set only
+    # specifying the bit size of pointers.
+    feature.feature('address-model', ['16', '32', '64'], ['propagated', 'optional'])
+
+    # Type of CPU architecture to compile for.
+    feature.feature('architecture', [
+        # x86 and x86-64
+        'x86',
+
+        # ia64
+        'ia64',
+
+        # Sparc
+        'sparc',
+
+        # RS/6000 & PowerPC
+        'power',
+
+        # MIPS/SGI
+        'mips1', 'mips2', 'mips3', 'mips4', 'mips32', 'mips32r2', 'mips64',
+
+        # HP/PA-RISC
+        'parisc',
+        
+        # Advanced RISC Machines
+        'arm',
+
+        # Combined architectures for platforms/toolsets that support building for
+        # multiple architectures at once. "combined" would be the default multi-arch
+        # for the toolset.
+        'combined',
+        'combined-x86-power'],
+
+        ['propagated', 'optional'])
+
+    # The specific instruction set in an architecture to compile.
+    feature.feature('instruction-set', [
+        # x86 and x86-64
+        'i386', 'i486', 'i586', 'i686', 'pentium', 'pentium-mmx', 'pentiumpro', 'pentium2', 'pentium3',
+        'pentium3m', 'pentium-m', 'pentium4', 'pentium4m', 'prescott', 'nocona', 'conroe', 'conroe-xe',
+        'conroe-l', 'allendale', 'mermon', 'mermon-xe', 'kentsfield', 'kentsfield-xe', 'penryn', 'wolfdale',
+        'yorksfield', 'nehalem', 'k6', 'k6-2', 'k6-3', 'athlon', 'athlon-tbird', 'athlon-4', 'athlon-xp',
+        'athlon-mp', 'k8', 'opteron', 'athlon64', 'athlon-fx', 'winchip-c6', 'winchip2', 'c3', 'c3-2',
+
+        # ia64
+        'itanium', 'itanium1', 'merced', 'itanium2', 'mckinley',
+
+        # Sparc
+        'v7', 'cypress', 'v8', 'supersparc', 'sparclite', 'hypersparc', 'sparclite86x', 'f930', 'f934',
+        'sparclet', 'tsc701', 'v9', 'ultrasparc', 'ultrasparc3',
+
+        # RS/6000 & PowerPC
+        '401', '403', '405', '405fp', '440', '440fp', '505', '601', '602',
+        '603', '603e', '604', '604e', '620', '630', '740', '7400',
+        '7450', '750', '801', '821', '823', '860', '970', '8540',
+        'power-common', 'ec603e', 'g3', 'g4', 'g5', 'power', 'power2',
+        'power3', 'power4', 'power5', 'powerpc', 'powerpc64', 'rios',
+        'rios1', 'rsc', 'rios2', 'rs64a',
+
+        # MIPS
+        '4kc', '4kp', '5kc', '20kc', 'm4k', 'r2000', 'r3000', 'r3900', 'r4000',
+        'r4100', 'r4300', 'r4400', 'r4600', 'r4650',
+        'r6000', 'r8000', 'rm7000', 'rm9000', 'orion', 'sb1', 'vr4100',
+        'vr4111', 'vr4120', 'vr4130', 'vr4300',
+        'vr5000', 'vr5400', 'vr5500',
+
+        # HP/PA-RISC
+        '700', '7100', '7100lc', '7200', '7300', '8000',
+        
+        # Advanced RISC Machines
+        'armv2', 'armv2a', 'armv3', 'armv3m', 'armv4', 'armv4t', 'armv5',
+        'armv5t', 'armv5te', 'armv6', 'armv6j', 'iwmmxt', 'ep9312'],
+
+        ['propagated', 'optional'])
+    
     # Windows-specific features
     feature.feature ('user-interface', ['console', 'gui', 'wince', 'native', 'auto'], [])
     feature.feature ('variant', [], ['implicit', 'composite', 'propagated', 'symmetric'])
@@ -190,7 +315,7 @@
 
 class SearchedLibTarget (virtual_target.AbstractFileTarget):
     def __init__ (self, name, project, shared, real_name, search, action):
-        AbstractFileTarget.__init__ (self, name, False, 'SEARCHED_LIB', project, action)
+        virtual_target.AbstractFileTarget.__init__ (self, name, False, 'SEARCHED_LIB', project, action)
         
         self.shared_ = shared
         self.real_name_ = real_name
@@ -211,7 +336,8 @@
         project.manager ().engine ().add_not_file_target (target)
     
     def path (self):
-        pass
+        #FIXME: several functions rely on this not being None
+        return ""
 
 
 class CScanner (scanner.Scanner):
@@ -349,6 +475,7 @@
 ### }
 ### IMPORT $(__name__) : lib : : lib ;
 
+# Updated to trunk_at_47077
 class SearchedLibGenerator (generators.Generator):
     def __init__ (self, id = 'SearchedLibGenerator', composing = False, source_types = [], target_types_and_names = ['SEARCHED_LIB'], requirements = []):
         # TODO: the comment below looks strange. There are no requirements!
@@ -358,7 +485,7 @@
         # search.
         generators.Generator.__init__ (self, id, composing, source_types, target_types_and_names, requirements)
     
-    def run (self, project, name, prop_set, sources):
+    def run(self, project, name, prop_set, sources):
         if not name:
             return None
 
@@ -369,17 +496,22 @@
         properties = prop_set.raw ()
         shared = '<link>shared' in properties
 
-        a = NullAction (project.manager (), prop_set)
+        a = virtual_target.NullAction (project.manager(), prop_set)
         
-        real_name = feature.get_values ('<name>', properties) [0]
-        search = feature.get_values ('<search>', properties) [0]
-        t = SearchedLibTarget (name, project, shared, real_name, search, a)
+        real_name = feature.get_values ('<name>', properties)
+        if real_name:
+            real_name = real_name[0]
+        else:
+            real_nake = name
+        search = feature.get_values('<search>', properties)
+        usage_requirements = property_set.create(['<xdll-path>' + p for p in search])
+        t = SearchedLibTarget(name, project, shared, real_name, search, a)
 
         # We return sources for a simple reason. If there's
         #    lib png : z : <name>png ; 
         # the 'z' target should be returned, so that apps linking to
         # 'png' will link to 'z', too.
-        return (virtual_target.register (t), sources)
+        return(usage_requirements, [boost.build.manager.get_manager().virtual_targets().register(t)] + sources)
 
 generators.register (SearchedLibGenerator ())
 
@@ -440,18 +572,21 @@
         generators.Generator.__init__ (self, id, composing, source_types, target_types_and_names, requirements)
         
     def run (self, project, name, prop_set, sources):
-        lib_sources = prop_set.get ('<library>')
-        [ sources.append (project.manager ().get_object (x)) for x in lib_sources ]
+        lib_sources = prop_set.get('<library>')
+        [ sources.append (project.manager().get_object(x)) for x in lib_sources ]
         
         # Add <library-path> properties for all searched libraries
         extra = []
         for s in sources:
             if s.type () == 'SEARCHED_LIB':
-                search = s.search ()
-                extra.append (replace_grist (search, '<library-path>'))
+                search = s.search()
+                extra.append(replace_grist(search, '<library-path>'))
+
+        orig_xdll_path = []
                    
-        if prop_set.get ('<hardcode-dll-paths>') == ['true'] and type.is_derived (self.target_types_ [0], 'EXE'):
-            xdll_path = prop_set.get ('<xdll-path>')
+        if prop_set.get('<hardcode-dll-paths>') == ['true'] and type.is_derived(self.target_types_ [0], 'EXE'):
+            xdll_path = prop_set.get('<xdll-path>')
+            orig_xdll_path = [ replace_grist(x, '<dll-path>') for x in xdll_path ]
             # It's possible that we have libraries in sources which did not came
             # from 'lib' target. For example, libraries which are specified
             # just as filenames as sources. We don't have xdll-path properties
@@ -460,18 +595,24 @@
                 if type.is_derived (s.type (), 'SHARED_LIB') and not s.action ():
                     # Unfortunately, we don't have a good way to find the path
                     # to a file, so use this nasty approach.
-                    p = s.project ()
-                    location = path.root (s.name (), p.get ('source-location'))
-                    xdll_path.append (path.parent (location))
+                    p = s.project()
+                    location = path.root(s.name(), p.get('source-location'))
+                    xdll_path.append(path.parent(location))
                           
-            extra += [ replace_grist (x, '<dll-path>') for x in xdll_path ]
+            extra += [ replace_grist(x, '<dll-path>') for x in xdll_path ]
         
         if extra:
             prop_set = prop_set.add_raw (extra)
                         
-        result = generators.Generator.run (self, project, name, prop_set, sources)
+        result = generators.Generator.run(self, project, name, prop_set, sources)
+
+        if result:
+            ur = self.extra_usage_requirements(result, prop_set)
+            ur = ur.add(property_set.create(orig_xdll_path))
+        else:
+            return None
         
-        return (self.extra_usage_requirements (result, prop_set), result)
+        return(ur, result)
     
     def extra_usage_requirements (self, created_targets, prop_set):
         
@@ -485,13 +626,13 @@
             
             # TODO: is it safe to use the current directory? I think we should use 
             # another mechanism to allow this to be run from anywhere.
-            pwd = os.getcwd ()
+            pwd = os.getcwd()
             
             for t in created_targets:
-                if type.is_derived (t.type (), 'SHARED_LIB'):
-                    paths.append (path.root (path.make (t.path ()), pwd))
+                if type.is_derived(t.type(), 'SHARED_LIB'):
+                    paths.append(path.root(path.make(t.path()), pwd))
 
-            extra += replace_grist (paths, '<xdll-path>')
+            extra += replace_grist(paths, '<xdll-path>')
         
         # We need to pass <xdll-path> features that we've got from sources,
         # because if shared library is built, exe which uses it must know paths
@@ -501,11 +642,11 @@
         # Just pass all features in property_set, it's theorically possible
         # that we'll propagate <xdll-path> features explicitly specified by
         # the user, but then the user's to blaim for using internal feature.                
-        values = prop_set.get ('<xdll-path>')
-        extra += replace_grist (values, '<xdll-path>')
+        values = prop_set.get('<xdll-path>')
+        extra += replace_grist(values, '<xdll-path>')
         
         if extra:
-            result = property_set.create (extra)
+            result = property_set.create(extra)
 
         return result
 
@@ -521,31 +662,33 @@
         # Searched libraries are not passed as argument to linker
         # but via some option. So, we pass them to the action
         # via property. 
-        properties2 = prop_set.raw ()
+        properties2 = prop_set.raw()
         fsa = []
         fst = []
         for s in sources:
-            if type.is_derived (s.type (), 'SEARCHED_LIB'):
-                name = s.real_name ()
-                if s.shared ():
-                    fsa.append (name)
+            if type.is_derived(s.type(), 'SEARCHED_LIB'):
+                name = s.real_name()
+                if s.shared():
+                    fsa.append(name)
 
                 else:
-                    fst.append (name)
+                    fst.append(name)
 
             else:
-                sources2.append (s)
+                sources2.append(s)
 
-        properties2 += '&&'.join (replace_grist (fsa, '<find-shared-library>'))
-        properties2 += '&&'.join (replace_grist (fst, '<find-static-library>'))
+        if fsa:
+            properties2 += [replace_grist('&&'.join(fsa), '<find-shared-library>')]
+        if fst:
+            properties2 += [replace_grist('&&'.join(fst), '<find-static-library>')]
                 
-        spawn = generators.Generator.generated_targets (self, sources2, property_set.create (properties2), project, name)
+        spawn = generators.Generator.generated_targets(self, sources2, property_set.create(properties2), project, name)
         
         return spawn
 
 
-def register_linker (id, source_types, target_types, requirements):
-    g = LinkingGenerator(id, 1, source_types, target_types, requirements)
+def register_linker(id, source_types, target_types, requirements):
+    g = LinkingGenerator(id, True, source_types, target_types, requirements)
     generators.register(g)
 
 class ArchiveGenerator (generators.Generator):

Modified: branches/build/python_port/python/boost/build/tools/common.py
==============================================================================
--- branches/build/python_port/python/boost/build/tools/common.py	(original)
+++ branches/build/python_port/python/boost/build/tools/common.py	2008-07-07 00:30:47 EDT (Mon, 07 Jul 2008)
@@ -3,12 +3,13 @@
 #  all copies. This software is provided "as is" without express or implied
 #  warranty, and with no claim as to its suitability for any purpose.
 
-""" Provides actions common to all toolsets, for as making directoies and
+""" Provides actions common to all toolsets, for as making directories and
     removing files.
 """
 
 import re
 import bjam
+import os
 
 from boost.build.build import feature
 from boost.build.util.utility import *
@@ -20,7 +21,7 @@
     """ Clear the module state. This is mainly for testing purposes.
         Note that this must be called _after_ resetting the module 'feature'.
     """    
-    global __had_unspecified_value, __had_value, __declared_subfeature, __all_signatures
+    global __had_unspecified_value, __had_value, __declared_subfeature, __all_signatures, __debug_configuration
     
     # Stores toolsets without specified initialization values.
     __had_unspecified_value = {}
@@ -33,6 +34,8 @@
     
     # Stores all signatures of the toolsets.
     __all_signatures = {}
+
+    __debug_configuration = '--debug-configuration' in bjam.variable('ARGV')
     
 reset ()
 
@@ -115,6 +118,34 @@
     # FIXME: we actually don't add any subfeatures to the condition
     return [condition]
 
+# Ported from trunk_at_47077
+def get_invocation_command_nodefault(
+    toolset, tool, user_provided_command, additional_paths=[], path_last=None):
+    """
+        A helper rule to get the command to invoke some tool. If
+        'user-provided-command' is not given, tries to find binary named 'tool' in
+        PATH and in the passed 'additional-path'. Otherwise, verifies that the first
+        element of 'user-provided-command' is an existing program.
+        
+        This rule returns the command to be used when invoking the tool. If we can't
+        find the tool, a warning is issued. If 'path-last' is specified, PATH is
+        checked after 'additional-paths' when searching for 'tool'.
+    """
+    if not user_provided_command:
+        command = find_tool(tool, additional_paths, path_last) 
+        if not command and __debug_configuration:
+            print "warning: toolset", toolset, "initialization: can't find tool, tool"
+            #FIXME
+            #print "warning: initialized from" [ errors.nearest-user-location ] ;
+    else:
+        command = check_tool(user_provided_command)
+        if not command and __debug_configuration:
+            print "warning: toolset", toolset, "initialization:"
+            print "warning: can't find user-provided command", user_provided_command
+            #FIXME
+            #ECHO "warning: initialized from" [ errors.nearest-user-location ]
+            
+    return command
 
 def get_invocation_command (toolset, tool, user_provided_command = None, additional_paths = None, path_last = None):
     """ A helper rule to get the command to invoke some tool. The rule is either passed
@@ -157,28 +188,20 @@
 
     return command
 
-
-###################################################################
-# Still to port.
-# Original lines are prefixed with "### "
-#
-### # Given an invocation command,
-### # return the absolute path to the command. This works even if commnad
-### # has not path element and is present in PATH.
-### rule get-absolute-tool-path ( command )
-### {
-###     if $(command:D)
-###     {
-###         return $(command:D) ;
-###     }
-###     else
-###     {
-###         local m = [ GLOB [ modules.peek : PATH Path path ] : $(command) $(command).exe ] ;
-###         return $(m[1]:D) ;
-###     }    
-### }
-
-
+def get_absolute_tool_path(command):
+    """
+        Given an invocation command,
+        return the absolute path to the command. This works even if commnad
+        has not path element and is present in PATH.
+    """
+    if os.path.dirname(command):
+        return os.path.dirname(command)
+    else:
+        programs = path.programs_path()
+        m = path.glob(programs, [command, command + '.exe' ])
+        if not len(m):
+            print "Could not find:", command, "in", programs
+        return os.path.dirname(m[0])
 
 def find_tool (name, additional_paths = None, path_last = False):
     """ Attempts to find tool (binary) named 'name' in PATH and in 'additiona-paths'.
@@ -242,10 +265,10 @@
 
     assert (command)
     toolset.flags (tool, 'CONFIG_COMMAND', condition, [command])
-    toolset.flags (tool + '_compile', 'OPTIONS', condition, feature.get_values ('<compileflags>', options))
-    toolset.flags (tool + '_compile_c', 'OPTIONS', condition, feature.get_values ('<cflags>', options))
-    toolset.flags (tool + '_compile_c++', 'OPTIONS', condition, feature.get_values ('<cxxflags>', options))
-    toolset.flags (tool + '_link', 'OPTIONS', condition, feature.get_values ('<linkflags>', options))
+    toolset.flags (tool + '.compile', 'OPTIONS', condition, feature.get_values ('<compileflags>', options))
+    toolset.flags (tool + '.compile.c', 'OPTIONS', condition, feature.get_values ('<cflags>', options))
+    toolset.flags (tool + '.compile.c++', 'OPTIONS', condition, feature.get_values ('<cxxflags>', options))
+    toolset.flags (tool + '.link', 'OPTIONS', condition, feature.get_values ('<linkflags>', options))
 
 
 ### # returns the location of the "program files" directory on a windows

Modified: branches/build/python_port/python/boost/build/tools/gcc.py
==============================================================================
--- branches/build/python_port/python/boost/build/tools/gcc.py	(original)
+++ branches/build/python_port/python/boost/build/tools/gcc.py	2008-07-07 00:30:47 EDT (Mon, 07 Jul 2008)
@@ -1,286 +1,813 @@
-#  Copyright (c) 2001 David Abrahams.
-#  Copyright (c) 2002-2003 Rene Rivera.
-#  Copyright (c) 2002-2003 Vladimir Prus.
+# Status: being ported by Steven Watanabe
+# Base revision: 47077
+# TODO: common.jam needs to be ported
+# TODO: generators.jam needs to have register_c_compiler.
 #
-#  Use, modification and distribution is subject to the Boost Software
-#  License Version 1.0. (See accompanying file LICENSE_1_0.txt or
-#  http://www.boost.org/LICENSE_1_0.txt)
-
-import os.path
-from boost.build.tools import common, builtin, unix
-from boost.build.build import feature, toolset, type, generators
-from boost.build.util.utility import *
+# Copyright 2001 David Abrahams.
+# Copyright 2002-2006 Rene Rivera.
+# Copyright 2002-2003 Vladimir Prus.
+#  Copyright (c) 2005 Reece H. Dunn.
+# Copyright 2006 Ilya Sokolov.
+# Copyright 2007 Roland Schwarz
+# Copyright 2007 Boris Gubenko.
+# Copyright 2008 Steven Watanabe
+#
+# Distributed under the Boost Software License, Version 1.0.
+#    (See accompanying file LICENSE_1_0.txt or copy at
+#          http://www.boost.org/LICENSE_1_0.txt)
+
+###import toolset : flags ;
+###import property ;
+###import generators ;
+###import os ;
+###import type ;
+###import feature ;
+###import "class" : new ;
+###import set ;
+###import common ;
+###import errors ;
+###import property-set ;
+###import pch ;
+###import regex ;
+
+import os
+import subprocess
+import re
+
+import bjam
+
+from boost.build.tools import unix, common, rc, pch, builtin
+from boost.build.build import feature, type, toolset, generators
+from boost.build.util.utility import os_name, on_windows
 from boost.build.manager import get_manager
+from boost.build.build.generators import Generator
+from boost.build.build.toolset import flags
+from boost.build.util.utility import to_seq
 
+__debug = None
 
-feature.extend ('toolset', ['gcc'])
+def debug():
+    global __debug
+    if __debug is None:
+        __debug = "--debug-generators" in bjam.variable("ARGV")        
+    return __debug
 
-toolset.inherit_generators ('gcc', [], 'unix', ['unix_link', 'unix_link_dll'])
-toolset.inherit_flags ('gcc', 'unix')
-toolset.inherit_rules ('gcc', 'unix')
+feature.extend('toolset', ['gcc'])
 
-# Make the "o" suffix used for gcc toolset on all
-# platforms
-type.set_generated_target_suffix ('OBJ', ['<toolset>gcc'], 'o')
-type.set_generated_target_suffix ('STATIC_LIB', ['<toolset>gcc'], 'a')
 
+toolset.inherit_generators('gcc', [], 'unix', ['unix.link', 'unix.link.dll'])
+toolset.inherit_flags('gcc', 'unix')
+toolset.inherit_rules('gcc', 'unix')
 
-def init (version = None, command = None, options = None):
-    """ Initializes the gcc toolset for the given version.
-        If necessary, command may be used to specify where the compiler
-        is located.
-        The parameter 'options' is a space-delimited list of options, each
-        one being specified as <option-name>option-value. Valid option names
-        are: cxxflags, linkflags and linker-type. Accepted values for linker-type
-        are gnu and sun, gnu being the default.
-        Example:
-          using gcc : 3.4 : : <cxxflags>foo <linkflags>bar <linker-type>sun ;
-    """
-    options = to_seq (options)
+generators.override('gcc.prebuilt', 'builtin.prebuilt')
+generators.override('gcc.searched-lib-generator', 'searched-lib-generator')
 
-    condition = common.check_init_parameters ('gcc', ('version', version))
-    
-    command = common.get_invocation_command ('gcc', 'g++', command)
-
-    common.handle_options ('gcc', condition, command, options)
-    
-    linker = feature.get_values ('<linker-type>', options)
-    if not linker:
-        linker = 'gnu'
+# Target naming is determined by types/lib.jam and the settings below this
+# comment.
+#
+# On *nix:
+#     libxxx.a     static library
+#     libxxx.so    shared library
+#
+# On windows (mingw):
+#     libxxx.lib   static library
+#     xxx.dll      DLL
+#     xxx.lib      import library
+#
+# On windows (cygwin) i.e. <target-os>cygwin
+#     libxxx.a     static library
+#     xxx.dll      DLL
+#     libxxx.dll.a import library
+#
+# Note: user can always override by using the <tag>@rule
+#       This settings have been choosen, so that mingw
+#       is in line with msvc naming conventions. For
+#       cygwin the cygwin naming convention has been choosen.
 
-    init_link_flags ('gcc', linker, condition)
+# Make the "o" suffix used for gcc toolset on all
+# platforms
+type.set_generated_target_suffix('OBJ', ['<toolset>gcc'], 'o')
+type.set_generated_target_suffix('STATIC_LIB', ['<toolset>gcc', '<target-os>cygwin'], 'a')
 
+type.set_generated_target_suffix('IMPORT_LIB', ['<toolset>gcc', '<target-os>cygwin'], 'dll.a')
+type.set_generated_target_prefix('IMPORT_LIB', ['<toolset>gcc', '<target-os>cygwin'], 'lib')
 
-def gcc_compile_cpp(targets, sources, properties):
-    # Some extensions are compiled as C++ by default. For others, we need
-    # to pass -x c++.
-    # We could always pass -x c++ but distcc does not work with it.
-    extension = os.path.splitext (sources [0]) [1]
-    lang = ''
-    if not extension in ['.cc', '.cp', '.cxx', '.cpp', '.c++', '.C']:
-        lang = '-x c++'
-    get_manager().engine ().set_target_variable (targets, 'LANG', lang)
+__machine_match = re.compile('^([^ ]+)')
+__version_match = re.compile('^([0-9.]+)')
 
-engine = get_manager().engine()
-engine.register_action ('gcc.compile.c++',
-                        '"$(CONFIG_COMMAND)" $(LANG) -Wall -ftemplate-depth-100 $(OPTIONS) -D$(DEFINES) -I"$(INCLUDES)" -c -o "$(<)" "$(>)"',
-                        function=gcc_compile_cpp)
+def init(version = None, command = None, options = None):
+    """
+        Initializes the gcc toolset for the given version. If necessary, command may
+        be used to specify where the compiler is located. The parameter 'options' is a
+        space-delimited list of options, each one specified as
+        <option-name>option-value. Valid option names are: cxxflags, linkflags and
+        linker-type. Accepted linker-type values are gnu, darwin, osf, hpux or sun
+        and the default value will be selected based on the current OS.
+        Example:
+          using gcc : 3.4 : : <cxxflags>foo <linkflags>bar <linker-type>sun ;
+    """
 
-builtin.register_c_compiler ('gcc.compile.c++', ['CPP'], ['OBJ'], ['<toolset>gcc'])
+    options = to_seq(options)
 
+    # Information about the gcc command...
+    #   The command.
+    command = to_seq(common.get_invocation_command('gcc', 'g++', command))
+    #   The root directory of the tool install.
+    root = feature.get_values('<root>', options) ;
+    #   The bin directory where to find the command to execute.
+    bin = None
+    #   The flavor of compiler.
+    flavor = feature.get_values('<flavor>', options)
+    #   Autodetect the root and bin dir if not given.
+    if command:
+        if not bin:
+            bin = common.get_absolute_tool_path(command[-1])
+        if not root:
+            root = os.path.dirname(bin)
+    #   Autodetect the version and flavor if not given.
+    if command:
+        machine_info = subprocess.Popen(command + ['-dumpmachine'], stdout=subprocess.PIPE).communicate()[0]
+        machine = __machine_match.search(machine_info).group(1)
+
+        version_info = subprocess.Popen(command + ['-dumpversion'], stdout=subprocess.PIPE).communicate()[0]
+        version = __version_match.search(version_info).group(1)
+        if not flavor and machine.find('mingw') != -1:
+            flavor = 'mingw'
+
+    condition = None
+    if flavor:
+        condition = common.check_init_parameters('gcc',
+            ('version', version),
+            ('flavor', flavor))
+    else:
+        condition = common.check_init_parameters('gcc',
+            ('version', version))
 
-def gcc_compile_c (manager, targets, sources, properties):
-    # If we use the name g++ then default file suffix -> language mapping
-    # does not work. So have to pass -x option. Maybe, we can work around this
-    # by allowing the user to specify both C and C++ compiler names.
-    manager.engine ().set_target_variable (targets, 'LANG', '-x c')
+    if command:
+        command = command[0]
 
-engine.register_action ('gcc.compile.c',
-                        '"$(CONFIG_COMMAND)" $(LANG) -Wall $(OPTIONS) -D$(DEFINES) -I"$(INCLUDES)" -c -o "$(<)" "$(>)"',
-                        function=gcc_compile_c)
+    common.handle_options('gcc', condition, command, options)
 
-builtin.register_c_compiler ('gcc.compile.c', ['C'], ['OBJ'], ['<toolset>gcc'])
+    linker = feature.get_values('<linker-type>', options)
+    if not linker:
+        if os_name() == 'OSF':
+            linker = 'osf'
+        elif os_name() == 'HPUX':
+            linker = 'hpux' ;
+        else:
+            linker = 'gnu'
+    ## NOTE: this comes from later in this module
+    init_link_flags('gcc', linker, condition)
+
+    # If gcc is installed in non-standard location, we'd need to add
+    # LD_LIBRARY_PATH when running programs created with it (for unit-test/run
+    # rules).
+    if command:
+        # On multilib 64-bit boxes, there are both 32-bit and 64-bit libraries
+        # and all must be added to LD_LIBRARY_PATH. The linker will pick the
+        # right onces. Note that we don't provide a clean way to build 32-bit
+        # binary with 64-bit compiler, but user can always pass -m32 manually.
+        lib_path = [os.path.join(root, 'bin'),
+                    os.path.join(root, 'lib'),
+                    os.path.join(root, 'lib32'),
+                    os.path.join(root, 'lib64')]
+        if debug():
+            print 'notice: using gcc libraries ::', condition, '::', lib_path
+        toolset.flags('gcc.link', 'RUN_PATH', condition, lib_path)
+
+    # If it's not a system gcc install we should adjust the various programs as
+    # needed to prefer using the install specific versions. This is essential
+    # for correct use of MinGW and for cross-compiling.
+
+    # - The archive builder.
+    ##TODO: what is search-path?
+    archiver = common.get_invocation_command('gcc',
+            'ar', feature.get_values('<archiver>', options), bin, ['search-path'])
+    toolset.flags('gcc.archive', '.AR', condition, archiver[0])
+    if debug():
+        print 'notice: using gcc archiver ::', condition, '::', archiver[0]
+
+    # - The resource compiler.
+    rc_command = common.get_invocation_command_nodefault('gcc',
+            'windres', feature.get_values('<rc>', options), bin, ['search-path'])
+    rc_type = feature.get_values('<rc-type>', options)
+
+    if not rc_type:
+        rc_type = 'windres'
+
+    if not rc_command:
+        # If we can't find an RC compiler we fallback to a null RC compiler that
+        # creates empty object files. This allows the same Jamfiles to work
+        # across the board. The null RC uses the assembler to create the empty
+        # objects, so configure that.
+        rc_command = common.get_invocation_command('gcc', 'as', [], bin, ['search-path'])
+        rc_type = 'null'
+    rc.configure(rc_command, condition, '<rc-type>' + rc_type)
+
+###if [ os.name ] = NT
+###{
+###    # This causes single-line command invocation to not go through .bat files,
+###    # thus avoiding command-line length limitations.
+###    JAMSHELL = % ;
+###}
+
+#FIXME: when register_c_compiler is moved to
+# generators, these should be updated
+builtin.register_c_compiler('gcc.compile.c++', ['CPP'], ['OBJ'], ['<toolset>gcc'])
+builtin.register_c_compiler('gcc.compile.c', ['C'], ['OBJ'], ['<toolset>gcc'])
+builtin.register_c_compiler('gcc.compile.asm', ['ASM'], ['OBJ'], ['<toolset>gcc'])
+
+# pch support
+
+# The compiler looks for a precompiled header in each directory just before it
+# looks for the include file in that directory. The name searched for is the
+# name specified in the #include directive with ".gch" suffix appended. The
+# logic in gcc-pch-generator will make sure that BASE_PCH suffix is appended to
+# full name of the header.
+
+type.set_generated_target_suffix('PCH', ['<toolset>gcc'], 'gch')
+
+# GCC-specific pch generator.
+class GccPchGenerator(pch.PchGenerator):
+
+    # Inherit the __init__ method
+
+    def run_pch(self, project, name, prop_set, sources):
+        # Find the header in sources. Ignore any CPP sources.
+        header = None
+        for s in sources:
+            if type.is_derived(s.type, 'H'):
+                header = s
+
+        # Error handling: Base header file name should be the same as the base
+        # precompiled header name.
+        header_name = header.name
+        header_basename = os.path.basename(header_name).rsplit('.', 1)[0]
+        if header_basename != name:
+            location = project.project_module
+            ###FIXME:
+            raise Exception()
+            ### errors.user-error "in" $(location)": pch target name `"$(name)"' should be the same as the base name of header file `"$(header-name)"'" ;
+
+        pch_file = Generator.run(self, project, name, prop_set, [header])
+
+        # return result of base class and pch-file property as usage-requirements
+        # FIXME: what about multiple results from generator.run?
+        return (property_set.create('<pch-file>' + pch_file[0], '<cflags>-Winvalid-pch'),
+                pch_file)
+
+    # Calls the base version specifying source's name as the name of the created
+    # target. As result, the PCH will be named whatever.hpp.gch, and not
+    # whatever.gch.
+    def generated_targets(self, sources, prop_set, project, name = None):
+        name = sources[0].name
+        return Generator.generated_targets(self, sources,
+            prop_set, project, name)
+
+# Note: the 'H' source type will catch both '.h' header and '.hpp' header. The
+# latter have HPP type, but HPP type is derived from H. The type of compilation
+# is determined entirely by the destination type.
+generators.register(GccPchGenerator('gcc.compile.c.pch', False, ['H'], ['C_PCH'], ['<pch>on', '<toolset>gcc' ]))
+generators.register(GccPchGenerator('gcc.compile.c++.pch', False, ['H'], ['CPP_PCH'], ['<pch>on', '<toolset>gcc' ]))
+
+# Override default do-nothing generators.
+generators.override('gcc.compile.c.pch', 'pch.default-c-pch-generator')
+generators.override('gcc.compile.c++.pch', 'pch.default-cpp-pch-generator')
 
+flags('gcc.compile', 'PCH_FILE', ['<pch>on'], ['<pch-file>'])
 
 # Declare flags and action for compilation
-toolset.flags ('gcc.compile', 'OPTIONS', ['<optimization>off'], ['-O0'])
-toolset.flags ('gcc.compile', 'OPTIONS', ['<optimization>speed'], ['-O3'])
-toolset.flags ('gcc.compile', 'OPTIONS', ['<optimization>space'], ['-Os'])
-
-toolset.flags ('gcc.compile', 'OPTIONS', ['<inlining>off'], ['-fno-inline'])
-toolset.flags ('gcc.compile', 'OPTIONS', ['<inlining>on'], ['-Wno-inline'])
-toolset.flags ('gcc.compile', 'OPTIONS', ['<inlining>full'], ['-finline-functions', '-Wno-inline'])
-
-toolset.flags ('gcc.compile', 'OPTIONS', ['<debug-symbols>on'], ['-g'])
-toolset.flags ('gcc.compile', 'OPTIONS', ['<profiling>on'], ['-pg'])
-
-# On cygwin and mingw, gcc generates position independent code by default,
-# and warns if -fPIC is specified. This might not be the right way
-# of checking if we're using cygwin. For example, it's possible 
-# to run cygwin gcc from NT shell, or using crosscompiling.
-# But we'll solve that problem when it's time. In that case
-# we'll just add another parameter to 'init' and move this login
+flags('gcc.compile', 'OPTIONS', ['<optimization>off'], ['-O0'])
+flags('gcc.compile', 'OPTIONS', ['<optimization>speed'], ['-O3'])
+flags('gcc.compile', 'OPTIONS', ['<optimization>space'], ['-Os'])
+
+flags('gcc.compile', 'OPTIONS', ['<inlining>off'], ['-fno-inline'])
+flags('gcc.compile', 'OPTIONS', ['<inlining>on'], ['-Wno-inline'])
+flags('gcc.compile', 'OPTIONS', ['<inlining>full'], ['-finline-functions', '-Wno-inline'])
+
+flags('gcc.compile', 'OPTIONS', ['<warnings>off'], ['-w'])
+flags('gcc.compile', 'OPTIONS', ['<warnings>on'], ['-Wall'])
+flags('gcc.compile', 'OPTIONS', ['<warnings>all'], ['-Wall', '-pedantic'])
+flags('gcc.compile', 'OPTIONS', ['<warnings-as-errors>on'], ['-Werror'])
+
+flags('gcc.compile', 'OPTIONS', ['<debug-symbols>on'], ['-g'])
+flags('gcc.compile', 'OPTIONS', ['<profiling>on'], ['-pg'])
+flags('gcc.compile', 'OPTIONS', ['<rtti>off'], ['-fno-rtti'])
+
+# On cygwin and mingw, gcc generates position independent code by default, and
+# warns if -fPIC is specified. This might not be the right way of checking if
+# we're using cygwin. For example, it's possible to run cygwin gcc from NT
+# shell, or using crosscompiling. But we'll solve that problem when it's time.
+# In that case we'll just add another parameter to 'init' and move this login
 # inside 'init'.
 if not os_name () in ['CYGWIN', 'NT']:
-    toolset.flags ('gcc.compile', 'OPTIONS', ['<link>shared', '<main-target-type>LIB'], ['-fPIC'])
+    print "osname:", os_name()
+    # This logic will add -fPIC for all compilations:
+    #
+    # lib a : a.cpp b ;
+    # obj b : b.cpp ;
+    # exe c : c.cpp a d ;
+    # obj d : d.cpp ;
+    #
+    # This all is fine, except that 'd' will be compiled with -fPIC even though
+    # it's not needed, as 'd' is used only in exe. However, it's hard to detect
+    # where a target is going to be used. Alternative, we can set -fPIC only
+    # when main target type is LIB but than 'b' will be compiled without -fPIC.
+    # In x86-64 that will lead to link errors. So, compile everything with
+    # -fPIC.
+    #
+    # Yet another alternative would be to create propagated <sharedable>
+    # feature, and set it when building shared libraries, but that's hard to
+    # implement and will increase target path length even more.
+    flags('gcc.compile', 'OPTIONS', ['<link>shared'], ['-fPIC'])
+
+if os_name() != 'NT' and os_name() != 'OSF' and os_name() != 'HPUX':
+    # OSF does have an option called -soname but it doesn't seem to work as
+    # expected, therefore it has been disabled.
+    HAVE_SONAME   = ''
+    SONAME_OPTION = '-h'
+
+
+flags('gcc.compile', 'USER_OPTIONS', [], ['<cflags>'])
+flags('gcc.compile.c++', 'USER_OPTIONS',[], ['<cxxflags>'])
+flags('gcc.compile', 'DEFINES', [], ['<define>'])
+flags('gcc.compile', 'INCLUDES', [], ['<include>'])
 
-if os_name () != 'NT':
-    HAVE_SONAME = True
-else:
-    HAVE_SONAME = False
-
-toolset.flags ('gcc.compile', 'OPTIONS', [], ['<cflags>'])
-toolset.flags ('gcc.compile.c++', 'OPTIONS', [], ['<cxxflags>'])
-toolset.flags ('gcc.compile', 'DEFINES', [], ['<define>'])
-toolset.flags ('gcc.compile', 'INCLUDES', [], ['<include>'])
-
-class GccLinkingGenerator (unix.UnixLinkingGenerator):
-    
-    """ The class which check that we don't try to use
-        the <link-runtime>static property while creating or using shared library,
-        since it's not supported by gcc/libc.
-    """
-    def generated_targets (self, sources, prop_set, project, name):
-        if '<link-runtime>static' in prop_set.raw ():
-            m = ''
-            if self.id () == "gcc.link.dll":
-                m = "on gcc, DLLs can't be build with <link-runtime>static."
-            else:
-                for s in sources:
-                    source_type = s.type ()
-                    if source_type and  type.is_derived (source_type, 'SHARED_LIB'):
-                        m = "on gcc, using DLLs together with the <link-runtime>static options is not possible."
-
-            if m:
-                raise UserError (m + " It's suggested to use <link-runtime>static together with the <link>static")
-
-        return unix.UnixLinkingGenerator.generated_targets (self, sources, prop_set, project, name)
-
-def gcc_link (targets, sources, properties):
-    get_manager().engine ().set_target_variable (targets, 'SPACE', " ")
-
-engine.register_action('gcc.link', '"$(CONFIG_COMMAND)" -L"$(LINKPATH)" -Wl,-R$(SPACE)-Wl,"$(RPATH)" -Wl,-rpath-link$(SPACE)-Wl,"$(RPATH_LINK)" -o "$(<)" "$(>)" "$(LIBRARIES)" -l$(FINDLIBS-ST) -l$(FINDLIBS-SA) $(OPTIONS)',
-                       bound_list=['LIBRARIES'],
-                       function=gcc_link)
-
-generators.register (GccLinkingGenerator ('gcc.link', True, ['LIB', 'OBJ'], ['EXE'], ['<toolset>gcc']))
-
-
-def gcc_link_dll (manager, target, sources, properties):
-    manager.engine ().set_target_variable (target, 'SPACE', " ")
+engine = get_manager().engine()
 
-# TODO: how to set 'bind LIBRARIES'?
-engine.register_action('gcc.link.dll', '"$(CONFIG_COMMAND)" -L"$(LINKPATH)" -Wl,-R$(SPACE)-Wl,"$(RPATH)" -o "$(<)" $(HAVE_SONAME)-Wl,-h$(SPACE)-Wl,$(<[1]:D=) -shared "$(>)"  "$(LIBRARIES)" -l$(FINDLIBS-ST) -l$(FINDLIBS-SA) $(OPTIONS)',
-                       bound_list=['LIBRARIES'],
-                       function=gcc_link_dll)
+engine.register_action('gcc.compile.c++.pch', 
+    '"$(CONFIG_COMMAND)" -x c++-header $(OPTIONS) -D$(DEFINES) -I"$(INCLUDES)" -c -o "$(<)" "$(>)"')
 
-generators.register (GccLinkingGenerator ('gcc.link.dll', True, ['LIB', 'OBJ'], ['SHARED_LIB'], ['<toolset>gcc']))
+engine.register_action('gcc.compile.c.pch',
+    '"$(CONFIG_COMMAND)" -x c-header $(OPTIONS) -D$(DEFINES) -I"$(INCLUDES)" -c -o "$(<)" "$(>)"')
 
-### generators.override gcc.prebuilt : builtin.prebuilt ;
-### generators.override gcc.searched-lib-generator : searched-lib-generator ;
 
+def gcc_compile_cpp(targets, sources, properties):
+    # Some extensions are compiled as C++ by default. For others, we need to
+    # pass -x c++. We could always pass -x c++ but distcc does not work with it.
+    extension = os.path.splitext (sources [0]) [1]
+    lang = ''
+    if not extension in ['.cc', '.cp', '.cxx', '.cpp', '.c++', '.C']:
+        lang = '-x c++'
+    get_manager().engine().set_target_variable (targets, 'LANG', lang)
+    # FIXME: don't know how to translate this
+    ##DEPENDS $(<) : [ on $(<) return $(PCH_FILE) ]
+
+def gcc_compile_c(targets, sources, properties):
+    # If we use the name g++ then default file suffix -> language mapping does
+    # not work. So have to pass -x option. Maybe, we can work around this by
+    # allowing the user to specify both C and C++ compiler names.
+    #if $(>:S) != .c
+    #{
+        get_manager().engine().set_target_variable (targets, 'LANG', '-x c')
+    #}
+    #FIXME: don't know how to translate this
+    ##DEPENDS $(<) : [ on $(<) return $(PCH_FILE) ] ;
+
+engine.register_action(
+    'gcc.compile.c++',
+    '"$(CONFIG_COMMAND)" $(LANG) -ftemplate-depth-128 $(OPTIONS) ' +
+        '$(USER_OPTIONS) -D$(DEFINES) -I"$(PCH_FILE:D)" -I"$(INCLUDES)" ' +
+        '-c -o "$(<:W)" "$(>:W)"',
+    function=gcc_compile_cpp,
+    bound_list=['PCH_FILE'])
+
+engine.register_action(
+    'gcc.compile.c',
+    '"$(CONFIG_COMMAND)" $(LANG) $(OPTIONS) $(USER_OPTIONS) -D$(DEFINES) ' +
+        '-I"$(PCH_FILE:D)" -I"$(INCLUDES)" -c -o "$(<)" "$(>)"',
+    function=gcc_compile_c,
+    bound_list=['PCH_FILE'])
+
+def gcc_compile_asm(targets, sources, properties):
+    get_manager().engine().set_target_variable(targets, 'LANG', '-x assembler-with-cpp')
+
+engine.register_action(
+    'gcc.compile.asm',
+    '"$(CONFIG_COMMAND)" $(LANG) $(OPTIONS) -D$(DEFINES) -I"$(INCLUDES)" -c -o "$(<)" "$(>)"',
+    function=gcc_compile_asm)
 
-# Declare flags for linking
-# First, the common flags
-toolset.flags ('gcc.link', 'OPTIONS', ['<debug-symbols>on'], ['-g'])
-toolset.flags ('gcc.link', 'OPTIONS', ['<profiling>on'], ['-pg'])
-toolset.flags ('gcc.link', 'OPTIONS', [], ['<linkflags>'])
-toolset.flags ('gcc.link', 'LINKPATH', [], ['<library-path>'])
-toolset.flags ('gcc.link', 'FINDLIBS-ST', [], ['<find-static-library>'])
-toolset.flags ('gcc.link', 'FINDLIBS-SA', [], ['<find-shared-library>'])
-toolset.flags ('gcc.link', 'LIBRARIES', [], ['<library-file>'])
 
-### # For <link-runtime>static we made sure there are no dynamic libraries 
-### # in the link
-toolset.flags ('gcc.link', 'OPTIONS', ['<link-runtime>static'], ['-static'])
+class GccLinkingGenerator(unix.UnixLinkingGenerator):
+    """
+        The class which check that we don't try to use the <runtime-link>static
+        property while creating or using shared library, since it's not supported by
+        gcc/libc.
+    """
+    def run(self, project, name, prop_set, sources):
+        # TODO: Replace this with the use of a target-os property.
 
-def init_link_flags (tool, linker, condition):
-    """ Sets the vendor specific flags.
+        no_static_link = False
+        if bjam.variable('UNIX'):
+            no_static_link = True;
+        ##FIXME: what does this mean?
+##        {
+##            switch [ modules.peek : JAMUNAME ]
+##            {
+##                case * : no-static-link = true ;
+##            }
+##        }
+
+        properties = prop_set.raw()
+        reason = None
+        if no_static_link and '<runtime-link>static' in properties:
+            if '<link>shared' in properties:
+                reason = "On gcc, DLL can't be build with '<runtime-link>static'."
+            elif type.is_derived(self.target_types[0], 'EXE'):
+                for s in sources:
+                    source_type = s.type()
+                    if source_type and type.is_derived(source_type, 'SHARED_LIB'):
+                        reason = "On gcc, using DLLS together with the " +\
+                                 "<runtime-link>static options is not possible "
+        if reason:
+            print 'warning:', reason
+            print 'warning:',\
+                "It is suggested to use '<runtime-link>static' together",\
+                "with '<link>static'." ;
+            return
+        else:
+            generated_targets = unix.UnixLinkingGenerator.run(self, project,
+                name, prop_set, sources)
+            return generated_targets
+
+__IMPLIB_COMMAND = None
+if on_windows():
+    __IMPLIB_COMMAND = '-Wl,--out-implib,'
+    generators.register(
+        GccLinkingGenerator('gcc.link', True,
+            ['OBJ', 'SEARCHED_LIB', 'STATIC_LIB', 'IMPORT_LIB'],
+            [ 'EXE' ],
+            [ '<toolset>gcc' ]))
+    generators.register(
+        GccLinkingGenerator('gcc.link.dll', True,
+            ['OBJ', 'SEARCHED_LIB', 'STATIC_LIB', 'IMPORT_LIB'],
+            ['IMPORT_LIB', 'SHARED_LIB'],
+            ['<toolset>gcc']))
+else:
+    generators.register(
+        GccLinkingGenerator('gcc.link', True,
+            ['LIB', 'OBJ'],
+            ['EXE'],
+            ['<toolset>gcc']))
+    generators.register(
+        GccLinkingGenerator('gcc.link.dll', True,
+            ['LIB', 'OBJ'],
+            ['SHARED_LIB'],
+            ['<toolset>gcc']))
+
+# Declare flags for linking.
+# First, the common flags.
+flags('gcc.link', 'OPTIONS', ['<debug-symbols>on'], ['-g'])
+flags('gcc.link', 'OPTIONS', ['<profiling>on'], ['-pg'])
+flags('gcc.link', 'USER_OPTIONS', [], ['<linkflags>'])
+flags('gcc.link', 'LINKPATH', [], ['<library-path>'])
+flags('gcc.link', 'FINDLIBS-ST', [], ['<find-static-library>'])
+flags('gcc.link', 'FINDLIBS-SA', [], ['<find-shared-library>'])
+flags('gcc.link', 'LIBRARIES', [], ['<library-file>'])
+
+# For <runtime-link>static we made sure there are no dynamic libraries in the
+# link. On HP-UX not all system libraries exist as archived libraries (for
+# example, there is no libunwind.a), so, on this platform, the -static option
+# cannot be specified.
+if os_name() != 'HPUX':
+    flags('gcc.link', 'OPTIONS', ['<runtime-link>static'], ['-static'])
+
+# Now, the vendor specific flags.
+# The parameter linker can be either gnu, darwin, osf, hpux or sun.
+def init_link_flags(toolset, linker, condition):
+    """
+        Now, the vendor specific flags.
+        The parameter linker can be either gnu, darwin, osf, hpux or sun.
     """
+    toolset_link = toolset + '.link'
     if linker == 'gnu':
-        # Strip the binary when no debugging is needed.
-        # We use --strip-all flag as opposed to -s since icc
-        # (intel's compiler) is generally option-compatible with
-        # and inherits from gcc toolset, but does not support -s
-        toolset.flags (tool + '_link', 'OPTIONS', condition + ['<debug-symbols>off'], ['-Wl,--strip-all'])
-        toolset.flags (tool + '_link', 'RPATH', condition, ['<dll-path>'])
-        toolset.flags (tool + '_link', 'RPATH_LINK', condition, ['<xdll-path>'])
+        # Strip the binary when no debugging is needed. We use --strip-all flag
+        # as opposed to -s since icc (intel's compiler) is generally
+        # option-compatible with and inherits from the gcc toolset, but does not
+        # support -s.
+
+        # FIXME: what does unchecked translate to?
+        flags(toolset_link, 'OPTIONS', map(lambda x: x + '/<debug-symbols>off', condition), ['-Wl,--strip-all'])  # : unchecked ;
+        flags(toolset_link, 'RPATH',       condition,                      ['<dll-path>'])       # : unchecked ;
+        flags(toolset_link, 'RPATH_LINK',  condition,                      ['<xdll-path>'])      # : unchecked ;
+        flags(toolset_link, 'START-GROUP', condition,                      ['-Wl,--start-group'])# : unchecked ;
+        flags(toolset_link, 'END-GROUP',   condition,                      ['-Wl,--end-group'])  # : unchecked ;
+
+        # gnu ld has the ability to change the search behaviour for libraries
+        # referenced by -l switch. These modifiers are -Bstatic and -Bdynamic
+        # and change search for -l switches that follow them. The following list
+        # shows the tried variants.
+        # The search stops at the first variant that has a match.
+        # *nix: -Bstatic -lxxx
+        #    libxxx.a
+        #
+        # *nix: -Bdynamic -lxxx
+        #    libxxx.so
+        #    libxxx.a
+        #
+        # windows (mingw,cygwin) -Bstatic -lxxx
+        #    libxxx.a
+        #    xxx.lib
+        #
+        # windows (mingw,cygwin) -Bdynamic -lxxx
+        #    libxxx.dll.a
+        #    xxx.dll.a
+        #    libxxx.a
+        #    xxx.lib
+        #    cygxxx.dll (*)
+        #    libxxx.dll
+        #    xxx.dll
+        #    libxxx.a
+        #
+        # (*) This is for cygwin
+        # Please note that -Bstatic and -Bdynamic are not a guarantee that a
+        # static or dynamic lib indeed gets linked in. The switches only change
+        # search patterns!
+
+        # On *nix mixing shared libs with static runtime is not a good idea.
+        flags(toolset_link, 'FINDLIBS-ST-PFX',
+              map(lambda x: x + '/<runtime-link>shared', condition),
+            ['-Wl,-Bstatic']) # : unchecked ;
+        flags(toolset_link, 'FINDLIBS-SA-PFX',
+              map(lambda x: x + '/<runtime-link>shared', condition),
+            ['-Wl,-Bdynamic']) # : unchecked ;
+
+        # On windows allow mixing of static and dynamic libs with static
+        # runtime.
+        flags(toolset_link, 'FINDLIBS-ST-PFX',
+              map(lambda x: x + '/<runtime-link>static/<target-os>windows', condition),
+              ['-Wl,-Bstatic']) # : unchecked ;
+        flags(toolset_link, 'FINDLIBS-SA-PFX',
+              map(lambda x: x + '/<runtime-link>static/<target-os>windows', condition),
+              ['-Wl,-Bdynamic']) # : unchecked ;
+        flags(toolset_link, 'OPTIONS',
+              map(lambda x: x + '/<runtime-link>static/<target-os>windows', condition),
+              ['-Wl,-Bstatic']) # : unchecked ;
 
     elif linker == 'darwin':
-        # we can't pass -s to ld unless we also pass -static
-        # so we removed -s completly from OPTIONS and add it
-        # to ST_OPTIONS            
-        toolset.flags (tool + '_link', 'ST_OPTIONS', condition + ['<debug-symbols>off'], ['-s'])
-        toolset.flags (tool + '_link', 'RPATH', condition, ['<dll-path>'])
-        toolset.flags (tool + '_link', 'RPATH_LINK', condition, ['<xdll-path>'])
+        # On Darwin, the -s option to ld does not work unless we pass -static,
+        # and passing -static unconditionally is a bad idea. So, don't pass -s.
+        # at all, darwin.jam will use separate 'strip' invocation.
+        flags(toolset_link, 'RPATH', condition, ['<dll-path>']) # : unchecked ;
+        flags(toolset_link, 'RPATH_LINK', condition, ['<xdll-path>']) # : unchecked ;
+
+    elif linker == 'osf':
+        # No --strip-all, just -s.
+        flags(toolset_link, 'OPTIONS', map(lambda x: x + '/<debug-symbols>off', condition), ['-Wl,-s'])
+            # : unchecked ;
+        flags(toolset_link, 'RPATH', condition, ['<dll-path>']) # : unchecked ;
+        # This does not supports -R.
+        flags(toolset_link, 'RPATH_OPTION', condition, ['-rpath']) # : unchecked ;
+        # -rpath-link is not supported at all.
 
     elif linker == 'sun':
-        toolset.flags (tool + '_link', 'OPTIONS', condition + ['<debug-symbols>off'], ['-Wl,-s'])
-        toolset.flags (tool + '_link', 'RPATH', condition, ['<dll-path>'])
-        # Solaris linker does not have a separate -rpath-link, but
-        # allows to use -L for the same purpose.
-        toolset.flags (tool + '_link', 'LINKPATH', condition, ['<xdll-path>'])
-
-        # This permits shared libraries with non-PIC code on Solaris
-        # VP, 2004/09/07: Now that we have -fPIC hardcode in link.dll,
-        # the following is not needed. Whether -fPIC should be hardcoded,
-        # is a separate question.
-        # AH, 2004/10/16: it is still necessary because some tests link
-        # against static libraries that were compiled without PIC.
-        toolset.flags (tool + '_link', 'OPTIONS', condition + ['<link>shared'], ['-mimpure-text'])
+        flags(toolset_link, 'OPTIONS', map(lambda x: x + '/<debug-symbols>off', condition), ['-Wl,-s'])
+            # : unchecked ;
+        flags(toolset_link, 'RPATH', condition, ['<dll-path>']) # : unchecked ;
+        # Solaris linker does not have a separate -rpath-link, but allows to use
+        # -L for the same purpose.
+        flags(toolset_link, 'LINKPATH', condition, ['<xdll-path>']) # : unchecked ;
+
+        # This permits shared libraries with non-PIC code on Solaris.
+        # VP, 2004/09/07: Now that we have -fPIC hardcode in link.dll, the
+        # following is not needed. Whether -fPIC should be hardcoded, is a
+        # separate question.
+        # AH, 2004/10/16: it is still necessary because some tests link against
+        # static libraries that were compiled without PIC.
+        flags(toolset_link, 'OPTIONS', map(lambda x: x + '/<link>shared', condition), ['-mimpure-text'])
+            # : unchecked ;
+
+    elif linker == 'hpux':
+        flags(toolset_link, 'OPTIONS', map(lambda x: x + '/<debug-symbols>off', condition),
+            ['-Wl,-s']) # : unchecked ;
+        flags(toolset_link, 'OPTIONS', map(lambda x: x + '/<link>shared', condition),
+            ['-fPIC']) # : unchecked ;
 
     else:
-            raise UserError ("'%s' initialization: invalid linker '%s'\n" \
-                "The value '%s' specified for <linker> is not recognized.\n" \
-                "Possible values are: 'darwin', 'sun', 'gnu'" % (toolset, linker, linker))
-
-
-### if [ os.name ] = NT
-### {
-###     # This causes single-line command invocation to not go through
-###     # .bat files, thus avoiding command-line length limitations
-###     JAMSHELL = % ;  
-### }
-
-### # Declare action for creating static libraries
-### # The 'r' letter means to replace files in the archive
-### # The 'u' letter means only outdated files in the archive
-### #   should be replaced.
-### # The 'c' letter means suppresses warning in case the archive
-### #   does not exists yet. That warning is produced only on
-### #   some platforms, for whatever reasons.
-#def gcc_archive (manager, targets, sources, properties):
-#    pass
-
-engine.register_action('gcc.archive', 'ar ruc "$(<)" "$(>)"')
-
-### # Set up threading support. It's somewhat contrived, so perform it at the end,
-### # to avoid cluttering other code.
-### 
-### if [ os.on-windows ] 
-### {
-###     flags gcc OPTIONS <threading>multi : -mthreads ;
-### }
-### else if [ modules.peek : UNIX ] 
-### {
-###     switch [ modules.peek : JAMUNAME ]
-###     {
-###     case SunOS* :
-###         {
-###         flags gcc OPTIONS <threading>multi : -pthreads ;
-###         flags gcc FINDLIBS-SA <threading>multi : rt ;
-###         }
-###     case BeOS :
-###         {
-###         # BeOS has no threading options, don't set anything here.
-###         }
-###     case *BSD :
-###         {
-###         flags gcc OPTIONS <threading>multi : -pthread ;
-###         # there is no -lrt on BSD
-###         }
-###     case DragonFly :
-###         {
-###         flags gcc OPTIONS <threading>multi : -pthread ;
-###         # there is no -lrt on BSD - DragonFly is a FreeBSD variant,
-###         # which anoyingly doesn't say it's a *BSD.
-###         }
-###     case IRIX :
-###         {
-###         # gcc on IRIX does not support multi-threading, don't set anything here.
-###         }
-###     case HP_UX :
-###         {
-###         # gcc on HP-UX does not support multi-threading, don't set anything here
-###         }
-###     case Darwin :
-###         {
-###         # Darwin has no threading options, don't set anything here.
-###         }
-###     case * :
-###         {
-###         flags gcc OPTIONS <threading>multi : -pthread ;
-###         flags gcc FINDLIBS-SA <threading>multi : rt ;
-###         }
-###     }
-### }
+        # FIXME:
+        errors.user_error(
+        "$(toolset) initialization: invalid linker '$(linker)' " +
+        "The value '$(linker)' specified for <linker> is not recognized. " +
+        "Possible values are 'gnu', 'darwin', 'osf', 'hpux' or 'sun'")
+
+# Declare actions for linking.
+def gcc_link(targets, sources, properties):
+    engine = get_manager().engine()
+    engine.set_target_variable(targets, 'SPACE', ' ')
+    # Serialize execution of the 'link' action, since running N links in
+    # parallel is just slower. For now, serialize only gcc links, it might be a
+    # good idea to serialize all links.
+    engine.set_target_variable(targets, 'JAM_SEMAPHORE', '<s>gcc-link-semaphore')
+
+engine.register_action(
+    'gcc.link',
+    '"$(CONFIG_COMMAND)" -L"$(LINKPATH)" ' +
+        '-Wl,$(RPATH_OPTION:E=-R)$(SPACE)-Wl,"$(RPATH)" ' +
+        '-Wl,-rpath-link$(SPACE)-Wl,"$(RPATH_LINK)" -o "$(<)" ' +
+        '$(START-GROUP) "$(>)" "$(LIBRARIES)" $(FINDLIBS-ST-PFX) ' +
+        '-l$(FINDLIBS-ST) $(FINDLIBS-SA-PFX) -l$(FINDLIBS-SA) $(END-GROUP) ' +
+        '$(OPTIONS) $(USER_OPTIONS)',
+    function=gcc_link,
+    bound_list=['LIBRARIES'])
+
+# Default value. Mostly for the sake of intel-linux that inherits from gcc, but
+# does not have the same logic to set the .AR variable. We can put the same
+# logic in intel-linux, but that's hardly worth the trouble as on Linux, 'ar' is
+# always available.
+__AR = 'ar'
+
+flags('gcc.archive', 'AROPTIONS', [], ['<archiveflags>'])
+
+def gcc_archive(targets, sources, properties):
+    # Always remove archive and start again. Here's rationale from
+    #
+    # Andre Hentz:
+    #
+    # I had a file, say a1.c, that was included into liba.a. I moved a1.c to
+    # a2.c, updated my Jamfiles and rebuilt. My program was crashing with absurd
+    # errors. After some debugging I traced it back to the fact that a1.o was
+    # *still* in liba.a
+    #
+    # Rene Rivera:
+    #
+    # Originally removing the archive was done by splicing an RM onto the
+    # archive action. That makes archives fail to build on NT when they have
+    # many files because it will no longer execute the action directly and blow
+    # the line length limit. Instead we remove the file in a different action,
+    # just before building the archive.
+    #
+    # FIXME:
+    pass
+    ##local clean.a = $(targets[1])(clean) ;
+    ##TEMPORARY $(clean.a) ;
+    ##NOCARE $(clean.a) ;
+    ##LOCATE on $(clean.a) = [ on $(targets[1]) return $(LOCATE) ] ;
+    ##DEPENDS $(clean.a) : $(sources) ;
+    ##DEPENDS $(targets) : $(clean.a) ;
+    ##common.RmTemps $(clean.a) : $(targets) ;
+
+# Declare action for creating static libraries.
+# The letter 'r' means to add files to the archive with replacement. Since we
+# remove archive, we don't care about replacement, but there's no option "add
+# without replacement".
+# The letter 'c' suppresses the warning in case the archive does not exists yet.
+# That warning is produced only on some platforms, for whatever reasons.
+#FIXME: This was originally piecemeal
+engine.register_action('gcc.archive',
+                       '"$(.AR)" $(AROPTIONS) rc "$(<)" "$(>)"',
+                       function=gcc_archive)
+
+def gcc_link_dll(targets, sources, properties):
+    engine = get_manager().engine()
+    engine.set_target_variable(targets, 'SPACE', ' ')
+    engine.set_target_variable(targets, 'JAM_SEMAPHORE', '<s>gcc-link-semaphore')
+
+engine.register_action(
+    'gcc.link.dll',
+    # Differ from 'link' above only by -shared.
+    '"$(CONFIG_COMMAND)" -L"$(LINKPATH)" ' +
+        '-Wl,$(RPATH_OPTION:E=-R)$(SPACE)-Wl,"$(RPATH)" ' +
+        '"$(.IMPLIB-COMMAND)$(<[1])" -o "$(<[-1])" ' +
+        '$(HAVE_SONAME)-Wl,$(SONAME_OPTION)$(SPACE)-Wl,$(<[-1]:D=) ' +
+        '-shared $(START-GROUP) "$(>)" "$(LIBRARIES)" $(FINDLIBS-ST-PFX) ' +
+        '-l$(FINDLIBS-ST) $(FINDLIBS-SA-PFX) -l$(FINDLIBS-SA) $(END-GROUP) ' +
+        '$(OPTIONS) $(USER_OPTIONS)',
+    function = gcc_link_dll,
+    bound_list=['LIBRARIES'])
+
+# Set up threading support. It's somewhat contrived, so perform it at the end,
+# to avoid cluttering other code.
+
+if on_windows():
+    flags('gcc', 'OPTIONS', ['<threading>multi'], ['-mthreads'])
+elif bjam.variable('UNIX'):
+    jamuname = bjam.variable('JAMUNAME')
+    if jamuname.startswith('SunOS'):
+        flags('gcc', 'OPTIONS', ['<threading>multi'], ['-pthreads'])
+        flags('gcc', 'FINDLIBS-SA', [], ['rt'])
+    elif jamuname == 'BeOS':
+        # BeOS has no threading options, don't set anything here.
+        pass
+    elif jamuname.endswith('BSD'):
+        flags('gcc', 'OPTIONS', ['<threading>multi'], ['-pthread'])
+        # there is no -lrt on BSD
+    elif jamuname == 'DragonFly':
+        flags('gcc', 'OPTIONS', ['<threading>multi'], ['-pthread'])
+        # there is no -lrt on BSD - DragonFly is a FreeBSD variant,
+        # which anoyingly doesn't say it's a *BSD.
+    elif jamuname == 'IRIX':
+        # gcc on IRIX does not support multi-threading, don't set anything here.
+        pass
+    elif jamuname == 'Darwin':
+        # Darwin has no threading options, don't set anything here.
+        pass
+    else:
+        flags('gcc', 'OPTIONS', ['<threading>multi'], ['-pthread'])
+        flags('gcc', 'FINDLIBS-SA', [], ['rt'])
+
+def cpu_flags(toolset, variable, architecture, instruction_set, values, default=None):
+    #FIXME: for some reason this fails.  Probably out of date feature code
+##    if default:
+##        flags(toolset, variable,
+##              ['<architecture>' + architecture + '/<instruction-set>'],
+##              values)
+    flags(toolset, variable,
+          #FIXME: same as above
+          [##'<architecture>/<instruction-set>' + instruction_set,
+           '<architecture>' + architecture + '/<instruction-set>' + instruction_set],
+          values)
+
+# Set architecture/instruction-set options.
+#
+# x86 and compatible
+flags('gcc', 'OPTIONS', ['<architecture>x86/<address-model>32'], ['-m32'])
+flags('gcc', 'OPTIONS', ['<architecture>x86/<address-model>64'], ['-m64'])
+cpu_flags('gcc', 'OPTIONS', 'x86', 'i386', ['-march=i386'], default=True)
+cpu_flags('gcc', 'OPTIONS', 'x86', 'i486', ['-march=i486'])
+cpu_flags('gcc', 'OPTIONS', 'x86', 'i586', ['-march=i586'])
+cpu_flags('gcc', 'OPTIONS', 'x86', 'i686', ['-march=i686'])
+cpu_flags('gcc', 'OPTIONS', 'x86', 'pentium', ['-march=pentium'])
+cpu_flags('gcc', 'OPTIONS', 'x86', 'pentium-mmx', ['-march=pentium-mmx'])
+cpu_flags('gcc', 'OPTIONS', 'x86', 'pentiumpro', ['-march=pentiumpro'])
+cpu_flags('gcc', 'OPTIONS', 'x86', 'pentium2', ['-march=pentium2'])
+cpu_flags('gcc', 'OPTIONS', 'x86', 'pentium3', ['-march=pentium3'])
+cpu_flags('gcc', 'OPTIONS', 'x86', 'pentium3m', ['-march=pentium3m'])
+cpu_flags('gcc', 'OPTIONS', 'x86', 'pentium-m', ['-march=pentium-m'])
+cpu_flags('gcc', 'OPTIONS', 'x86', 'pentium4', ['-march=pentium4'])
+cpu_flags('gcc', 'OPTIONS', 'x86', 'pentium4m', ['-march=pentium4m'])
+cpu_flags('gcc', 'OPTIONS', 'x86', 'prescott', ['-march=prescott'])
+cpu_flags('gcc', 'OPTIONS', 'x86', 'nocona', ['-march=nocona'])
+cpu_flags('gcc', 'OPTIONS', 'x86', 'k6', ['-march=k6'])
+cpu_flags('gcc', 'OPTIONS', 'x86', 'k6-2', ['-march=k6-2'])
+cpu_flags('gcc', 'OPTIONS', 'x86', 'k6-3', ['-march=k6-3'])
+cpu_flags('gcc', 'OPTIONS', 'x86', 'athlon', ['-march=athlon'])
+cpu_flags('gcc', 'OPTIONS', 'x86', 'athlon-tbird', ['-march=athlon-tbird'])
+cpu_flags('gcc', 'OPTIONS', 'x86', 'athlon-4', ['-march=athlon-4'])
+cpu_flags('gcc', 'OPTIONS', 'x86', 'athlon-xp', ['-march=athlon-xp'])
+cpu_flags('gcc', 'OPTIONS', 'x86', 'athlon-mp', ['-march=athlon-mp'])
+##
+cpu_flags('gcc', 'OPTIONS', 'x86', 'k8', ['-march=k8'])
+cpu_flags('gcc', 'OPTIONS', 'x86', 'opteron', ['-march=opteron'])
+cpu_flags('gcc', 'OPTIONS', 'x86', 'athlon64', ['-march=athlon64'])
+cpu_flags('gcc', 'OPTIONS', 'x86', 'athlon-fx', ['-march=athlon-fx'])
+cpu_flags('gcc', 'OPTIONS', 'x86', 'winchip-c6', ['-march=winchip-c6'])
+cpu_flags('gcc', 'OPTIONS', 'x86', 'winchip2', ['-march=winchip2'])
+cpu_flags('gcc', 'OPTIONS', 'x86', 'c3', ['-march=c3'])
+cpu_flags('gcc', 'OPTIONS', 'x86', 'c3-2', ['-march=c3-2'])
+# Sparc
+flags('gcc', 'OPTIONS', ['<architecture>sparc/<address-model>32'], ['-m32'])
+flags('gcc', 'OPTIONS', ['<architecture>sparc/<address-model>64'], ['-m64'])
+cpu_flags('gcc', 'OPTIONS', 'sparc', 'c3', ['-mcpu=c3'], default=True)
+cpu_flags('gcc', 'OPTIONS', 'sparc', 'v7', ['-mcpu=v7'])
+cpu_flags('gcc', 'OPTIONS', 'sparc', 'cypress', ['-mcpu=cypress'])
+cpu_flags('gcc', 'OPTIONS', 'sparc', 'v8', ['-mcpu=v8'])
+cpu_flags('gcc', 'OPTIONS', 'sparc', 'supersparc', ['-mcpu=supersparc'])
+cpu_flags('gcc', 'OPTIONS', 'sparc', 'sparclite', ['-mcpu=sparclite'])
+cpu_flags('gcc', 'OPTIONS', 'sparc', 'hypersparc', ['-mcpu=hypersparc'])
+cpu_flags('gcc', 'OPTIONS', 'sparc', 'sparclite86x', ['-mcpu=sparclite86x'])
+cpu_flags('gcc', 'OPTIONS', 'sparc', 'f930', ['-mcpu=f930'])
+cpu_flags('gcc', 'OPTIONS', 'sparc', 'f934', ['-mcpu=f934'])
+cpu_flags('gcc', 'OPTIONS', 'sparc', 'sparclet', ['-mcpu=sparclet'])
+cpu_flags('gcc', 'OPTIONS', 'sparc', 'tsc701', ['-mcpu=tsc701'])
+cpu_flags('gcc', 'OPTIONS', 'sparc', 'v9', ['-mcpu=v9'])
+cpu_flags('gcc', 'OPTIONS', 'sparc', 'ultrasparc', ['-mcpu=ultrasparc'])
+cpu_flags('gcc', 'OPTIONS', 'sparc', 'ultrasparc3', ['-mcpu=ultrasparc3'])
+# RS/6000 & PowerPC
+flags('gcc', 'OPTIONS', ['<architecture>power/<address-model>32'], ['-m32'])
+flags('gcc', 'OPTIONS', ['<architecture>power/<address-model>64'], ['-m64'])
+cpu_flags('gcc', 'OPTIONS', 'power', '403', ['-mcpu=403'])
+cpu_flags('gcc', 'OPTIONS', 'power', '505', ['-mcpu=505'])
+cpu_flags('gcc', 'OPTIONS', 'power', '601', ['-mcpu=601'])
+cpu_flags('gcc', 'OPTIONS', 'power', '602', ['-mcpu=602'])
+cpu_flags('gcc', 'OPTIONS', 'power', '603', ['-mcpu=603'])
+cpu_flags('gcc', 'OPTIONS', 'power', '603e', ['-mcpu=603e'])
+cpu_flags('gcc', 'OPTIONS', 'power', '604', ['-mcpu=604'])
+cpu_flags('gcc', 'OPTIONS', 'power', '604e', ['-mcpu=604e'])
+cpu_flags('gcc', 'OPTIONS', 'power', '620', ['-mcpu=620'])
+cpu_flags('gcc', 'OPTIONS', 'power', '630', ['-mcpu=630'])
+cpu_flags('gcc', 'OPTIONS', 'power', '740', ['-mcpu=740'])
+cpu_flags('gcc', 'OPTIONS', 'power', '7400', ['-mcpu=7400'])
+cpu_flags('gcc', 'OPTIONS', 'power', '7450', ['-mcpu=7450'])
+cpu_flags('gcc', 'OPTIONS', 'power', '750', ['-mcpu=750'])
+cpu_flags('gcc', 'OPTIONS', 'power', '801', ['-mcpu=801'])
+cpu_flags('gcc', 'OPTIONS', 'power', '821', ['-mcpu=821'])
+cpu_flags('gcc', 'OPTIONS', 'power', '823', ['-mcpu=823'])
+cpu_flags('gcc', 'OPTIONS', 'power', '860', ['-mcpu=860'])
+cpu_flags('gcc', 'OPTIONS', 'power', '970', ['-mcpu=970'])
+cpu_flags('gcc', 'OPTIONS', 'power', '8540', ['-mcpu=8540'])
+cpu_flags('gcc', 'OPTIONS', 'power', 'power', ['-mcpu=power'])
+cpu_flags('gcc', 'OPTIONS', 'power', 'power2', ['-mcpu=power2'])
+cpu_flags('gcc', 'OPTIONS', 'power', 'power3', ['-mcpu=power3'])
+cpu_flags('gcc', 'OPTIONS', 'power', 'power4', ['-mcpu=power4'])
+cpu_flags('gcc', 'OPTIONS', 'power', 'power5', ['-mcpu=power5'])
+cpu_flags('gcc', 'OPTIONS', 'power', 'powerpc', ['-mcpu=powerpc'])
+cpu_flags('gcc', 'OPTIONS', 'power', 'powerpc64', ['-mcpu=powerpc64'])
+cpu_flags('gcc', 'OPTIONS', 'power', 'rios', ['-mcpu=rios'])
+cpu_flags('gcc', 'OPTIONS', 'power', 'rios1', ['-mcpu=rios1'])
+cpu_flags('gcc', 'OPTIONS', 'power', 'rios2', ['-mcpu=rios2'])
+cpu_flags('gcc', 'OPTIONS', 'power', 'rsc', ['-mcpu=rsc'])
+cpu_flags('gcc', 'OPTIONS', 'power', 'rs64a', ['-mcpu=rs64'])
+# AIX variant of RS/6000 & PowerPC
+flags('gcc', 'OPTIONS', ['<architecture>power/<address-model>32/<target-os>aix'], ['-maix32'])
+flags('gcc', 'OPTIONS', ['<architecture>power/<address-model>64/<target-os>aix'], ['-maix64'])
+flags('gcc', 'AROPTIONS', ['<architecture>power/<address-model>64/<target-os>aix'], ['-X 64'])

Added: branches/build/python_port/python/boost/build/tools/pch.py
==============================================================================
--- (empty file)
+++ branches/build/python_port/python/boost/build/tools/pch.py	2008-07-07 00:30:47 EDT (Mon, 07 Jul 2008)
@@ -0,0 +1,83 @@
+# Status: Being ported by Steven Watanabe
+# Base revision: 47077
+#
+# Copyright (c) 2005 Reece H. Dunn.
+# Copyright 2006 Ilya Sokolov
+# Copyright (c) 2008 Steven Watanabe
+#
+# Use, modification and distribution is subject to the Boost Software
+# License Version 1.0. (See accompanying file LICENSE_1_0.txt or
+# http://www.boost.org/LICENSE_1_0.txt)
+
+##### Using Precompiled Headers (Quick Guide) #####
+#
+# Make precompiled mypch.hpp:
+#
+#    import pch ;
+#
+#    cpp-pch mypch
+#      : # sources
+#        mypch.hpp
+#      : # requiremnts
+#        <toolset>msvc:<source>mypch.cpp
+#      ;
+#
+# Add cpp-pch to sources:
+#
+#    exe hello
+#      : main.cpp hello.cpp mypch
+#      ;
+
+from boost.build.build import type, feature, generators
+
+type.register('PCH', ['pch'])
+type.register('C_PCH', [], 'PCH')
+type.register('CPP_PCH', [], 'PCH')
+
+# Control precompiled header (PCH) generation.
+feature.feature('pch',
+                ['on', 'off'],
+                ['propagated'])
+
+feature.feature('pch-header', [], ['free', 'dependency'])
+feature.feature('pch-file', [], ['free', 'dependency'])
+
+class PchGenerator(generators.Generator):
+    """
+        Base PCH generator. The 'run' method has the logic to prevent this generator
+        from being run unless it's being used for a top-level PCH target.
+    """
+    def action_class(self):
+        return 'compile-action'
+
+    def run(self, project, name, prop_set, sources):
+        if not name:
+            # Unless this generator is invoked as the top-most generator for a
+            # main target, fail. This allows using 'H' type as input type for
+            # this generator, while preventing Boost.Build to try this generator
+            # when not explicitly asked for.
+            #
+            # One bad example is msvc, where pch generator produces both PCH
+            # target and OBJ target, so if there's any header generated (like by
+            # bison, or by msidl), we'd try to use pch generator to get OBJ from
+            # that H, which is completely wrong. By restricting this generator
+            # only to pch main target, such problem is solved.
+            pass
+        else:
+            r = self.run_pch(project, name,
+                 prop_set.add_raw('<define>BOOST_BUILD_PCH_ENABLED'),
+                 sources)
+            return generators.add_usage_requirements(
+                r, ['<define>BOOST_BUILD_PCH_ENABLED'])
+
+    # This rule must be overridden by the derived classes.
+    def run_pch(self, project, name, prop_set, sources):
+        pass
+
+#FIXME: dummy-generator in builtins.jam needs to be ported.
+# NOTE: requirements are empty, default pch generator can be applied when
+# pch=off.
+###generators.register(
+###    [ new dummy-generator pch.default-c-pch-generator   : :   C_PCH ] ;
+###generators.register
+###    [ new dummy-generator pch.default-cpp-pch-generator : : CPP_PCH ] ;

Modified: branches/build/python_port/python/boost/build/tools/rc.py
==============================================================================
--- branches/build/python_port/python/boost/build/tools/rc.py	(original)
+++ branches/build/python_port/python/boost/build/tools/rc.py	2008-07-07 00:30:47 EDT (Mon, 07 Jul 2008)
@@ -54,7 +54,10 @@
         before calling this. And still get the functionality of build failures when
         the resource compiler can't be found.
     """
-    rc_type = feature.get_values('<rc-type>', options)[0]
+    rc_type = feature.get_values('<rc-type>', options)
+    if rc_type:
+        assert(len(rc_type) == 1)
+        rc_type = rc_type[0]
 
     if command and condition and rc_type:
         flags('rc.compile.resource', '.RC', condition, command)

Modified: branches/build/python_port/python/boost/build/tools/types/__init__.py
==============================================================================
--- branches/build/python_port/python/boost/build/tools/types/__init__.py	(original)
+++ branches/build/python_port/python/boost/build/tools/types/__init__.py	2008-07-07 00:30:47 EDT (Mon, 07 Jul 2008)
@@ -1,4 +1,5 @@
 __all__ = [
+    'asm',
     'cpp',
     'exe',
     'html',
@@ -11,7 +12,7 @@
     for i in __all__:
         m = __import__ (__name__ + '.' + i)
         reg = i + '.register ()'
-        exec (reg)
+        #exec (reg)
 
 # TODO: (PF) I thought these would be imported automatically. Anyone knows why they aren't?
 register_all ()

Added: branches/build/python_port/python/boost/build/tools/types/asm.py
==============================================================================
--- (empty file)
+++ branches/build/python_port/python/boost/build/tools/types/asm.py	2008-07-07 00:30:47 EDT (Mon, 07 Jul 2008)
@@ -0,0 +1,13 @@
+# Copyright Craig Rodrigues 2005.
+# Copyright (c) 2008 Steven Watanabe
+#
+# Distributed under the Boost
+# Software License, Version 1.0. (See accompanying
+# file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+from boost.build.build import type
+
+def register():
+    type.register_type('ASM', ['s', 'S', 'asm'])
+
+register()

Modified: branches/build/python_port/python/boost/build/tools/unix.py
==============================================================================
--- branches/build/python_port/python/boost/build/tools/unix.py	(original)
+++ branches/build/python_port/python/boost/build/tools/unix.py	2008-07-07 00:30:47 EDT (Mon, 07 Jul 2008)
@@ -21,7 +21,8 @@
     
     def run (self, project, name, prop_set, sources):
         result = builtin.LinkingGenerator.run (self, project, name, prop_set, sources)
-        set_library_order (project.manager (), sources, prop_set, result [1])
+        if result:
+            set_library_order (project.manager (), sources, prop_set, result [1])
                                 
         return result
     

Modified: branches/build/python_port/python/boost/build/util/path.py
==============================================================================
--- branches/build/python_port/python/boost/build/util/path.py	(original)
+++ branches/build/python_port/python/boost/build/util/path.py	2008-07-07 00:30:47 EDT (Mon, 07 Jul 2008)
@@ -430,12 +430,13 @@
     names = ['PATH', 'Path', 'path']
     
     for name in names:
-        raw.append (os.environ.get (name, ''))
-        
+        raw.append(os.environ.get (name, ''))
+    
     result = []
-    for p in raw:
-        if p:
-            result.append (make (p))
+    for elem in raw:
+        if elem:
+            for p in elem.split(os.path.pathsep):
+                result.append(make(p))
 
     return result
 

Modified: branches/build/python_port/python/boost/build/util/utility.py
==============================================================================
--- branches/build/python_port/python/boost/build/util/utility.py	(original)
+++ branches/build/python_port/python/boost/build/util/utility.py	2008-07-07 00:30:47 EDT (Mon, 07 Jul 2008)
@@ -130,7 +130,9 @@
     return (toolset, name)
 
 def os_name ():
-    return bjam.variable("OS")
+    result = bjam.variable("OS")
+    assert(len(result) == 1)
+    return result[0]
 
 def platform ():
     return bjam.variable("OSPLAT")