[Boost-commit] svn:boost r45463 - branches/build/python_port/python/boost/build/build

From: ghost_at_[hidden]
Date: 2008-05-18 00:07:00

Author: vladimir_prus
Date: 2008-05-18 00:07:00 EDT (Sun, 18 May 2008)
New Revision: 45463
URL: http://svn.boost.org/trac/boost/changeset/45463

Log:
Port type.jam
Text files modified: 
   branches/build/python_port/python/boost/build/build/type.py |   130 ++++++++++++++++++++--------------------
   1 files changed, 65 insertions(+), 65 deletions(-)

Modified: branches/build/python_port/python/boost/build/build/type.py
==============================================================================
--- branches/build/python_port/python/boost/build/build/type.py	(original)
+++ branches/build/python_port/python/boost/build/build/type.py	2008-05-18 00:07:00 EDT (Sun, 18 May 2008)
@@ -1,8 +1,13 @@
+# Status: being ported by Vladimir Prus
+# Base revision: 45462.
+
 #  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
 #  warranty, and with no claim as to its suitability for any purpose.
 
+
+
 import re
 import os
 import os.path
@@ -26,12 +31,12 @@
     """ Clear the module state. This is mainly for testing purposes.
         Note that this must be called _after_ resetting the module 'feature'.
     """    
-    global __suffixes, __suffixes_to_types, __types, __rule_names_to_types, __target_suffixes_cache
+    global __prefixes_suffixes, __suffixes_to_types, __types, __rule_names_to_types, __target_suffixes_cache
     
     __register_features ()
 
     # Stores suffixes for generated targets.
-    __suffixes = property.PropertyMap ()
+    __prefixes_suffixes = [property.PropertyMap(), property.PropertyMap()]
     
     # Maps suffixes to types
     __suffixes_to_types = {}
@@ -43,9 +48,6 @@
     # 'scanner': the scanner class registered for this type, if any
     __types = {}
 
-    # Maps main rule names to the corresponding type.
-    __rule_names_to_types = {}
-    
     # Caches suffixes for targets with certain properties.
     __target_suffixes_cache = {}
     
@@ -87,15 +89,17 @@
         # Specify mapping from suffixes to type
         register_suffixes (suffixes, type)
     
-    feature.extend_feature ('target-type', [type])
-    feature.extend_feature ('main-target-type', [type])
-    feature.extend_feature ('base-target-type', [type])
+    feature.extend('target-type', [type])
+    feature.extend('main-target-type', [type])
+    feature.extend('base-target-type', [type])
 
     if base_type:
         feature.compose ('<target-type>' + type, replace_grist (base_type, '<base-target-type>'))
         feature.compose ('<base-target-type>' + type, '<base-target-type>' + base_type)
 
-    __register_main_rule (type)
+    # FIXME: resolving recursive dependency.
+    from boost.build.manager import get_manager
+    get_manager().projects().project_rules().add_rule_for_type(type)
 
 def register_suffixes (suffixes, type):
     """ Specifies that targets with suffix from 'suffixes' have the type 'type'. 
@@ -184,55 +188,85 @@
         The 'suffix' parameter can be empty string ("") to indicate that
         no suffix should be used.
     """
-    properties.append ('<target-type>' + type)
-    __suffixes.insert (properties, suffix)
+    set_generated_target_ps(1, type, properties, suffix)
+
 
+    
 def change_generated_target_suffix (type, properties, suffix):
     """ Change the suffix previously registered for this type/properties 
         combination. If suffix is not yet specified, sets it.
     """
+    change_generated_target_ps(1, type, properties, suffix)
+
+def generated_target_suffix(type, properties):
+    return generated_target_ps(1, type, properties)
+
+# Sets a target prefix that should be used when generating targets of 'type'
+# with the specified properties. Can be called with empty properties if no
+# prefix for 'type' has been specified yet.
+#
+# The 'prefix' parameter can be empty string ("") to indicate that no prefix
+# should be used.
+#
+# Usage example: library names use the "lib" prefix on unix.
+def set_generated_target_prefix(type, properties, prefix):
+    set_generated_target_ps(0, type, properties, prefix)
+
+# Change the prefix previously registered for this type/properties combination.
+# If prefix is not yet specified, sets it.
+def change_generated_target_prefix(type, properties, prefix):
+    change_generated_target_ps(0, type, properties, prefix)
+
+def generated_target_prefix(type, properties):
+    return generated_target_ps(0, type, properties)
+
+def set_generated_target_ps(is_suffix, type, properties, val):
     properties.append ('<target-type>' + type)
-    prev = __suffixes.find_replace (properties, suffix)
+    __prefixes_suffixes[is_suffix].insert (properties, val)
 
+def change_generated_target_ps(is_suffix, type, properties, val):
+    properties.append ('<target-type>' + type)
+    prev = __prefixes_suffixes[is_suffix].find_replace(properties, val)
     if not prev:
-        set_generated_target_suffix (type, properties, suffix)
+        set_generated_target_ps(is_suffix, type, properties, val)
+
+# Returns either prefix or suffix (as indicated by 'is_suffix') that should be used
+# when generating a target of 'type' with the specified properties.
+# If no prefix/suffix is specified for 'type', returns prefix/suffix for
+# base type, if any.
+def generated_target_ps_real(is_suffix, type, properties):
 
-def generated_target_suffix_real (type, properties):
-    """Actual implementation of generated_target_suffix.
-    """ 
     result = ''
     found = False
     while type and not found:
-        result = __suffixes.find (['<target-type>' + type] + properties)
+        result = __prefixes_suffixes[is_suffix].find (['<target-type>' + type] + properties)
 
-        # If the suffix is explicitly set to empty string, we consider suffix
-        # to be found. If we did not compare with "", there would be no
-        # way for user to set empty suffix.
+        # Note that if the string is empty (""), but not null, we consider
+        # suffix found.  Setting prefix or suffix to empty string is fine.
         if result:
             found = True
 
         type = __types [type]['base']
 
-    if result == '':
-        result = None
-
+    if not result:
+        result = ''
     return result
 
-def generated_target_suffix (type, prop_set):
+def generated_target_ps(is_suffix, type, prop_set):
     """ Returns suffix that should be used when generating target of 'type',
         with the specified properties. If not suffix were specified for
         'type', returns suffix for base type, if any.
     """
-    key = type + str (prop_set)
+    key = str(is_suffix) + type + str(prop_set)
     v = __target_suffixes_cache.get (key, None)
 
     if not v:
-        v = generated_target_suffix_real (type, prop_set.raw ())
+        v = generated_target_ps_real(is_suffix, type, prop_set.raw())
         __target_suffixes_cache [key] = v
-    
+
     return v
 
-def type (filename):
+def type(filename):
     """ Returns file type given it's name. If there are several dots in filename,
         tries each suffix. E.g. for name of "file.so.1.2" suffixes "2", "1", and 
         "so"  will be tried.
@@ -240,10 +274,10 @@
     while 1:
         filename, suffix = os.path.splitext (filename)
         if not suffix: return None
-        suffix = suffix [1:]
+        suffix = suffix[1:]
         
-        if __suffixes_to_types.has_key (suffix):
-            return __suffixes_to_types [suffix]
+        if __suffixes_to_types.has_key(suffix):
+            return __suffixes_to_types[suffix]
 
 # NOTE: moved from tools/types/register
 def register_type (type, suffixes, base_type = None, os = []):
@@ -256,37 +290,3 @@
 
     if not os or os_name () in os:
         register (type, suffixes, base_type)
-
-
-
-######################################################################################
-# Private functions
-
-def main_target_rule (type, project, name, sources, requirements = [], default_build = None, usage_requirements = []):
-    targets = project.manager ().targets ()
-    return targets.create_typed_target (type, project.target (), name, sources, requirements, default_build, usage_requirements)
-
-    
-def __register_main_rule (type):
-    # We used to declare a main target rule only when 'main' parameter is specified. 
-    # However, it's hard to decide that a type *never* will need a main target rule 
-    # and so from time to time we needed to make yet another type 'main'. So, now 
-    # main target rule is defined for each type.
-     
-    main_rule_name = type_to_rule_name (type)
-    __rule_names_to_types [main_rule_name] = type
-
-    import boost.build.build.project
-    def xpto (project, name, sources, requirements = [], default_build = None, usage_requirements = []):
-        return main_target_rule (type, project, name, sources, requirements, default_build, usage_requirements)
-
-    # FIXME
-    #boost.build.build.project.ProjectModule.__dict__ [main_rule_name] = xpto
-
-
-def type_to_rule_name (type):
-    """ Given type, returns name of main target rule which creates
-        targets of that type.
-    """
-    # Lowercase everything.
-    return type.lower ()