boost_1_45_0/tools/build/v2/build_system.py - nest-learning-thermostat/5.0/boost - Git at Google

 # Status: being ported by Vladimir Prus.

 # Copyright 2003, 2005 Dave Abrahams
 # Copyright 2006 Rene Rivera
 # Copyright 2003, 2004, 2005, 2006, 2007 Vladimir Prus
 # Distributed under the Boost Software License, Version 1.0.
 # (See accompanying file LICENSE_1_0.txt or http://www.boost.org/LICENSE_1_0.txt)

 from b2.build.engine import Engine
 from b2.manager import Manager
 from b2.util.path import glob
 from b2.build import feature, property_set
 import b2.build.virtual_target
 from b2.build.targets import ProjectTarget
 from b2.util.sequence import unique
 import b2.build.build_request
 from b2.build.errors import ExceptionWithUserContext
 import b2.tools.common

 import bjam

 import os
 import sys

 # FIXME:
 # Returns the location of the build system. The primary use case
 # is building Boost, where it's sometimes needed to get location
 # of other components (like BoostBook files), and it's convenient
 # to use location relatively to Boost.Build path.
 #rule location ( )
 #{
 #    local r = [ modules.binding build-system ] ;
 #    return $(r:P) ;
 #}

 # FIXME:

 def get_boolean_option(name):
     match = "--" + name
     if match in argv:
         return 1
     else:
         return 0

 def get_string_option(name):
     match = "--" + name + "="

     for arg in argv:
         if arg.startswith(match):
             return arg[len(match):]
     return None

 def home_directories():
     if os.name == "nt":
         result = set()
         try:
             result.add(os.environ['HOMEDRIVE'] + os.environ['HOMEPATH'])
             result.add(os.environ['HOME'])
             result.add(os.environ['USERPROFILE'])
         except KeyError:
             pass
         return list(result)
     else:
         return [os.environ['HOME']]

 ignore_config = 0
 debug_config = 0

 def load_config(manager, basename, path):
     """Unless ignore-config is set, search configuration
     basename.jam in path and loads it.  The jamfile module
     for that file will be loaded 'basename'."""

     if not ignore_config:
         found = glob(path, [basename + ".jam"])
         if found:
             found = found[0]
         if debug_config:
             print "notice: searching '%s' for '%s.jam'" % (path, basename)
             if found:
                 print "notice: loading %s.jam from %s" % (basename, found)

         manager.projects().load_standalone(basename, found)

 def main():

     global argv
     argv = bjam.variable("ARGV")

     # FIXME: document this option.
     if "--profiling" in argv:
         import cProfile
         import pstats
         cProfile.runctx('main_real()', globals(), locals(), "stones.prof")

         stats = pstats.Stats("stones.prof")
         stats.strip_dirs()
         stats.sort_stats('time', 'calls')
         stats.print_callers(20)
     else:
         main_real()

 def main_real():

     global ignore_config
     global debug_config

     boost_build_path = bjam.variable("BOOST_BUILD_PATH")

     engine = Engine()

     global_build_dir = get_string_option("build-dir")
     debug_config = get_boolean_option("debug-configuration")

     manager = Manager(engine, global_build_dir)

     # This module defines types and generator and what not,
     # and depends on manager's existence
     import b2.tools.builtin


     # Check if we can load 'test-config.jam'. If we can, load it and
     # ignore user configs.

     test_config = glob(boost_build_path, ["test-config.jam"])
     if test_config:
         test_config = test_config[0]

     if test_config:
         if debug_config:
             print "notice: loading testing-config.jam from '%s'" % test_config
             print "notice: user-config.jam and site-config.jam will be ignored"

         manager.projects().load_standalone("test-config", test_config)


     ignore_config = test_config or get_boolean_option("ignore-config")
     user_path = home_directories() + boost_build_path

     site_path = ["/etc"] + user_path
     if bjam.variable("OS") in ["NT", "CYGWIN"]:
         site_path = [os.environ("SystemRoot")] + user_path

     load_config(manager, "site-config", site_path)

     user_config_path = get_string_option("user-config")
     if not user_config_path:
         user_config_path = os.environ.get("BOOST_BUILD_USER_CONFIG")

     if user_config_path:
         if debug_config:
             print "Loading explicitly specifier user configuration file:"
             print "    %s" % user_config_path

         manager.projects().load_standalone("user-config", user_config_path)

     else:
         load_config(manager, "user-config", user_path)


 # FIXME:
 ## #
 ## # Autoconfigure toolsets based on any instances of --toolset=xx,yy,...zz or
 ## # toolset=xx,yy,...zz in the command line
 ## #
 ## local option-toolsets = [ regex.split-list [ MATCH ^--toolset=(.*) : $(argv) ] : "," ] ;
 ## local feature-toolsets = [ regex.split-list [ MATCH ^toolset=(.*) : $(argv) ] : "," ] ;

 ## # if the user specified --toolset=..., we need to add toolset=... to
 ## # the build request
 ## local extra-build-request ;

     extra_build_request = []

 ## if ! $(ignore-config)
 ## {
 ##     for local t in $(option-toolsets) $(feature-toolsets)
 ##     {
 ##         # Parse toolset-version/properties
 ##         local (t-v,t,v) = [ MATCH (([^-/]+)-?([^/]+)?)/?.* : $(t) ] ;
 ##         local toolset-version = $((t-v,t,v)[1]) ;
 ##         local toolset = $((t-v,t,v)[2]) ;
 ##         local version = $((t-v,t,v)[3]) ;

 ##         if $(debug-config)
 ##         {
 ##             ECHO notice: [cmdline-cfg] Detected command-line request for
 ##               $(toolset-version): toolset= \"$(toolset)\" "version= \""$(version)\" ;
 ##         }

 ##         local known ;

 ##         # if the toolset isn't known, configure it now.
 ##         if $(toolset) in [ feature.values <toolset>  ]
 ##         {
 ##             known = true ;
 ##         }

 ##         if $(known) && $(version)
 ##           && ! [ feature.is-subvalue toolset : $(toolset) : version : $(version) ]
 ##         {
 ##             known = ;
 ##         }

 ##         if ! $(known)
 ##         {
 ##             if $(debug-config)
 ##             {
 ##                 ECHO notice: [cmdline-cfg] toolset $(toolset-version)
 ##                   not previously configured; configuring now ;
 ##             }
 ##             toolset.using $(toolset) : $(version) ;
 ##         }
 ##         else
 ##         {
 ##             if $(debug-config)
 ##             {
 ##                 ECHO notice: [cmdline-cfg] toolset $(toolset-version) already configured ;
 ##             }
 ##         }

 ##         # make sure we get an appropriate property into the build request in
 ##         # case the user used the "--toolset=..." form
 ##         if ! $(t) in $(argv)
 ##             && ! $(t) in $(feature-toolsets)
 ##         {
 ##             if $(debug-config)
 ##             {
 ##                 ECHO notice: [cmdline-cfg] adding toolset=$(t) "to build request." ;
 ##             }
 ##             extra-build-request += toolset=$(t) ;
 ##         }
 ##     }
 ## }


 # FIXME:
 ## if USER_MODULE in [ RULENAMES ]
 ## {
 ##     USER_MODULE site-config user-config ;
 ## }

     if get_boolean_option("version"):
         # FIXME: Move to a separate module. Include bjam
         # verision.
         print "Boost.Build M15 (Python port in development)"
         sys.exit(0)

     b2.tools.common.init(manager)

     # We always load project in "." so that 'use-project' directives has
     # any chance of been seen. Otherwise, we won't be able to refer to
     # subprojects using target ids.

     current_project = None
     projects = manager.projects()
     if projects.find(".", "."):
         current_project = projects.target(projects.load("."))

     # FIXME: revive this logic, when loading of gcc works
     if not feature.values("<toolset>") and not ignore_config and 0:
         default_toolset = "gcc" ;
         if bjam.variable("OS") == "NT":
             default_toolset = "msvc"

         print "warning: No toolsets are configured." ;
         print "warning: Configuring default toolset '%s'" % default_toolset
         print "warning: If the default is wrong, you may not be able to build C++ programs."
         print "warning: Use the \"--toolset=xxxxx\" option to override our guess."
         print "warning: For more configuration options, please consult"
         print "warning: http://boost.org/boost-build2/doc/html/bbv2/advanced/configuration.html"

         projects.project_rules().using([default_toolset])

     (target_ids, properties) = b2.build.build_request.from_command_line(
         argv[1:] + extra_build_request)

     if properties:
         expanded = b2.build.build_request.expand_no_defaults(properties)
         xexpanded = []
         for e in expanded:
             xexpanded.append(property_set.create(feature.split(e)))
         expanded = xexpanded
     else:
         expanded = [property_set.empty()]

     targets = []

     clean = get_boolean_option("clean")
     clean_all = get_boolean_option("clean-all")


     bjam_targets = []

     # Given a target id, try to find and return corresponding target.
     # This is only invoked when there's no Jamfile in "."
     # This code somewhat duplicates code in project-target.find but we can't  reuse
     # that code without project-targets instance.
     def find_target (target_id):
         split = target_id.split("//")
         pm = None
         if len(split) > 1:
             pm = projects.find(split[0], ".")
         else:
             pm = projects.find(target_id, ".")

         result = None
         if pm:
             result = projects.target(pm)

         if len(split) > 1:
             result = result.find(split[1])

     if not current_project and not target_ids:
         print "error: no Jamfile in current directory found, and no target references specified."
         sys.exit(1)

     for id in target_ids:
         if id == "clean":
             clean = 1
         else:
             t = None
             if current_project:
                 t = current_project.find(id, no_error=1)
             else:
                 t = find_target(id)

             if not t:
                 print "notice: could not find main target '%s'" % id
                 print "notice: assuming it's a name of file to create " ;
                 bjam_targets.append(id)
             else:
                 targets.append(t)

     if not targets:
         targets = [projects.target(projects.module_name("."))]

     virtual_targets = []

     # Virtual targets obtained when building main targets references on
     # the command line. When running
     #
     #   bjam --clean main_target
     #
     # we want to clean the files that belong only to that main target,
     # so we need to record which targets are produced.
     results_of_main_targets = []

     for p in expanded:
         manager.set_command_line_free_features(property_set.create(p.free()))

         for t in targets:
             try:
                 g = t.generate(p)
                 if not isinstance(t, ProjectTarget):
                     results_of_main_targets.extend(g.targets())
                 virtual_targets.extend(g.targets())
             except ExceptionWithUserContext, e:
                 e.report()
             except Exception:
                 raise

     # The cleaning is tricky. Say, if
     # user says:
     #
     #    bjam --clean foo
     #
     # where 'foo' is a directory, then we want to clean targets
     # which are in 'foo' or in any children Jamfiles, but not in any
     # unrelated Jamfiles. So, we collect the list of project under which
     # cleaning is allowed.
     #
     projects_to_clean = []
     targets_to_clean = []
     if clean or clean_all:
         for t in targets:
             if isinstance(t, ProjectTarget):
                 projects_to_clean.append(t.project_module())

             for t in results_of_main_targets:
                 # Don't include roots or sources.
                 targets_to_clean += b2.build.virtual_target.traverse(t)

     targets_to_clean = unique(targets_to_clean)

     is_child_cache_ = {}

     # Returns 'true' if 'project' is a child of 'current-project',
     # possibly indirect, or is equal to 'project'.
     # Returns 'false' otherwise.
     def is_child (project):

         r = is_child_cache_.get(project, None)
         if not r:
             if project in projects_to_clean:
                 r = 1
             else:
                 parent = manager.projects().attribute(project, "parent-module")
                 if parent and parent != "user-config":
                     r = is_child(parent)
                 else:
                     r = 0

             is_child_cache_[project] = r

         return r

     actual_targets = []
     for t in virtual_targets:
         actual_targets.append(t.actualize())


     bjam.call("NOTFILE", "all")
     bjam.call("DEPENDS", "all", actual_targets)

     if bjam_targets:
         bjam.call("UPDATE", ["<e>%s" % x for x in bjam_targets])
     elif clean_all:
         bjam.call("UPDATE", "clean-all")
     elif clean:
         to_clean = []
         for t in manager.virtual_targets().all_targets():
             p = t.project()

             # Remove only derived targets.
             if t.action() and \
                (t in targets_to_clean or is_child(p.project_module())):
                 to_clean.append(t)

         to_clean_actual = [t.actualize() for t in to_clean]
         manager.engine().set_update_action('common.Clean', 'clean',
                                            to_clean_actual, None)

         bjam.call("UPDATE", "clean")

     else:
         bjam.call("UPDATE", "all")
	# Status: being ported by Vladimir Prus.

	# Copyright 2003, 2005 Dave Abrahams
	# Copyright 2006 Rene Rivera
	# Copyright 2003, 2004, 2005, 2006, 2007 Vladimir Prus
	# Distributed under the Boost Software License, Version 1.0.
	# (See accompanying file LICENSE_1_0.txt or http://www.boost.org/LICENSE_1_0.txt)

	from b2.build.engine import Engine
	from b2.manager import Manager
	from b2.util.path import glob
	from b2.build import feature, property_set
	import b2.build.virtual_target
	from b2.build.targets import ProjectTarget
	from b2.util.sequence import unique
	import b2.build.build_request
	from b2.build.errors import ExceptionWithUserContext
	import b2.tools.common

	import bjam

	import os
	import sys

	# FIXME:
	# Returns the location of the build system. The primary use case
	# is building Boost, where it's sometimes needed to get location
	# of other components (like BoostBook files), and it's convenient
	# to use location relatively to Boost.Build path.
	#rule location ( )
	#{
	# local r = [ modules.binding build-system ] ;
	# return $(r:P) ;
	#}

	# FIXME:

	def get_boolean_option(name):
	match = "--" + name
	if match in argv:
	return 1
	else:
	return 0

	def get_string_option(name):
	match = "--" + name + "="

	for arg in argv:
	if arg.startswith(match):
	return arg[len(match):]
	return None

	def home_directories():
	if os.name == "nt":
	result = set()
	try:
	result.add(os.environ['HOMEDRIVE'] + os.environ['HOMEPATH'])
	result.add(os.environ['HOME'])
	result.add(os.environ['USERPROFILE'])
	except KeyError:
	pass
	return list(result)
	else:
	return [os.environ['HOME']]

	ignore_config = 0
	debug_config = 0

	def load_config(manager, basename, path):
	"""Unless ignore-config is set, search configuration
	basename.jam in path and loads it. The jamfile module
	for that file will be loaded 'basename'."""

	if not ignore_config:
	found = glob(path, [basename + ".jam"])
	if found:
	found = found[0]
	if debug_config:
	print "notice: searching '%s' for '%s.jam'" % (path, basename)
	if found:
	print "notice: loading %s.jam from %s" % (basename, found)

	manager.projects().load_standalone(basename, found)

	def main():

	global argv
	argv = bjam.variable("ARGV")

	# FIXME: document this option.
	if "--profiling" in argv:
	import cProfile
	import pstats
	cProfile.runctx('main_real()', globals(), locals(), "stones.prof")

	stats = pstats.Stats("stones.prof")
	stats.strip_dirs()
	stats.sort_stats('time', 'calls')
	stats.print_callers(20)
	else:
	main_real()

	def main_real():

	global ignore_config
	global debug_config

	boost_build_path = bjam.variable("BOOST_BUILD_PATH")

	engine = Engine()

	global_build_dir = get_string_option("build-dir")
	debug_config = get_boolean_option("debug-configuration")

	manager = Manager(engine, global_build_dir)

	# This module defines types and generator and what not,
	# and depends on manager's existence
	import b2.tools.builtin


	# Check if we can load 'test-config.jam'. If we can, load it and
	# ignore user configs.

	test_config = glob(boost_build_path, ["test-config.jam"])
	if test_config:
	test_config = test_config[0]

	if test_config:
	if debug_config:
	print "notice: loading testing-config.jam from '%s'" % test_config
	print "notice: user-config.jam and site-config.jam will be ignored"

	manager.projects().load_standalone("test-config", test_config)


	ignore_config = test_config or get_boolean_option("ignore-config")
	user_path = home_directories() + boost_build_path

	site_path = ["/etc"] + user_path
	if bjam.variable("OS") in ["NT", "CYGWIN"]:
	site_path = [os.environ("SystemRoot")] + user_path

	load_config(manager, "site-config", site_path)

	user_config_path = get_string_option("user-config")
	if not user_config_path:
	user_config_path = os.environ.get("BOOST_BUILD_USER_CONFIG")

	if user_config_path:
	if debug_config:
	print "Loading explicitly specifier user configuration file:"
	print " %s" % user_config_path

	manager.projects().load_standalone("user-config", user_config_path)

	else:
	load_config(manager, "user-config", user_path)


	# FIXME:
	## #
	## # Autoconfigure toolsets based on any instances of --toolset=xx,yy,...zz or
	## # toolset=xx,yy,...zz in the command line
	## #
	## local option-toolsets = [ regex.split-list [ MATCH ^--toolset=(.*) : $(argv) ] : "," ] ;
	## local feature-toolsets = [ regex.split-list [ MATCH ^toolset=(.*) : $(argv) ] : "," ] ;

	## # if the user specified --toolset=..., we need to add toolset=... to
	## # the build request
	## local extra-build-request ;

	extra_build_request = []

	## if ! $(ignore-config)
	## {
	## for local t in $(option-toolsets) $(feature-toolsets)
	## {
	## # Parse toolset-version/properties
	## local (t-v,t,v) = [ MATCH (([^-/]+)-?([^/]+)?)/?.* : $(t) ] ;
	## local toolset-version = $((t-v,t,v)[1]) ;
	## local toolset = $((t-v,t,v)[2]) ;
	## local version = $((t-v,t,v)[3]) ;

	## if $(debug-config)
	## {
	## ECHO notice: [cmdline-cfg] Detected command-line request for
	## $(toolset-version): toolset= \"$(toolset)\" "version= \""$(version)\" ;
	## }

	## local known ;

	## # if the toolset isn't known, configure it now.
	## if $(toolset) in [ feature.values <toolset> ]
	## {
	## known = true ;
	## }

	## if $(known) && $(version)
	## && ! [ feature.is-subvalue toolset : $(toolset) : version : $(version) ]
	## {
	## known = ;
	## }

	## if ! $(known)
	## {
	## if $(debug-config)
	## {
	## ECHO notice: [cmdline-cfg] toolset $(toolset-version)
	## not previously configured; configuring now ;
	## }
	## toolset.using $(toolset) : $(version) ;
	## }
	## else
	## {
	## if $(debug-config)
	## {
	## ECHO notice: [cmdline-cfg] toolset $(toolset-version) already configured ;
	## }
	## }

	## # make sure we get an appropriate property into the build request in
	## # case the user used the "--toolset=..." form
	## if ! $(t) in $(argv)
	## && ! $(t) in $(feature-toolsets)
	## {
	## if $(debug-config)
	## {
	## ECHO notice: [cmdline-cfg] adding toolset=$(t) "to build request." ;
	## }
	## extra-build-request += toolset=$(t) ;
	## }
	## }
	## }


	# FIXME:
	## if USER_MODULE in [ RULENAMES ]
	## {
	## USER_MODULE site-config user-config ;
	## }

	if get_boolean_option("version"):
	# FIXME: Move to a separate module. Include bjam
	# verision.
	print "Boost.Build M15 (Python port in development)"
	sys.exit(0)

	b2.tools.common.init(manager)

	# We always load project in "." so that 'use-project' directives has
	# any chance of been seen. Otherwise, we won't be able to refer to
	# subprojects using target ids.

	current_project = None
	projects = manager.projects()
	if projects.find(".", "."):
	current_project = projects.target(projects.load("."))

	# FIXME: revive this logic, when loading of gcc works
	if not feature.values("<toolset>") and not ignore_config and 0:
	default_toolset = "gcc" ;
	if bjam.variable("OS") == "NT":
	default_toolset = "msvc"

	print "warning: No toolsets are configured." ;
	print "warning: Configuring default toolset '%s'" % default_toolset
	print "warning: If the default is wrong, you may not be able to build C++ programs."
	print "warning: Use the \"--toolset=xxxxx\" option to override our guess."
	print "warning: For more configuration options, please consult"
	print "warning: http://boost.org/boost-build2/doc/html/bbv2/advanced/configuration.html"

	projects.project_rules().using([default_toolset])

	(target_ids, properties) = b2.build.build_request.from_command_line(
	argv[1:] + extra_build_request)

	if properties:
	expanded = b2.build.build_request.expand_no_defaults(properties)
	xexpanded = []
	for e in expanded:
	xexpanded.append(property_set.create(feature.split(e)))
	expanded = xexpanded
	else:
	expanded = [property_set.empty()]

	targets = []

	clean = get_boolean_option("clean")
	clean_all = get_boolean_option("clean-all")


	bjam_targets = []

	# Given a target id, try to find and return corresponding target.
	# This is only invoked when there's no Jamfile in "."
	# This code somewhat duplicates code in project-target.find but we can't reuse
	# that code without project-targets instance.
	def find_target (target_id):
	split = target_id.split("//")
	pm = None
	if len(split) > 1:
	pm = projects.find(split[0], ".")
	else:
	pm = projects.find(target_id, ".")

	result = None
	if pm:
	result = projects.target(pm)

	if len(split) > 1:
	result = result.find(split[1])

	if not current_project and not target_ids:
	print "error: no Jamfile in current directory found, and no target references specified."
	sys.exit(1)

	for id in target_ids:
	if id == "clean":
	clean = 1
	else:
	t = None
	if current_project:
	t = current_project.find(id, no_error=1)
	else:
	t = find_target(id)

	if not t:
	print "notice: could not find main target '%s'" % id
	print "notice: assuming it's a name of file to create " ;
	bjam_targets.append(id)
	else:
	targets.append(t)

	if not targets:
	targets = [projects.target(projects.module_name("."))]

	virtual_targets = []

	# Virtual targets obtained when building main targets references on
	# the command line. When running
	#
	# bjam --clean main_target
	#
	# we want to clean the files that belong only to that main target,
	# so we need to record which targets are produced.
	results_of_main_targets = []

	for p in expanded:
	manager.set_command_line_free_features(property_set.create(p.free()))

	for t in targets:
	try:
	g = t.generate(p)
	if not isinstance(t, ProjectTarget):
	results_of_main_targets.extend(g.targets())
	virtual_targets.extend(g.targets())
	except ExceptionWithUserContext, e:
	e.report()
	except Exception:
	raise

	# The cleaning is tricky. Say, if
	# user says:
	#
	# bjam --clean foo
	#
	# where 'foo' is a directory, then we want to clean targets
	# which are in 'foo' or in any children Jamfiles, but not in any
	# unrelated Jamfiles. So, we collect the list of project under which
	# cleaning is allowed.
	#
	projects_to_clean = []
	targets_to_clean = []
	if clean or clean_all:
	for t in targets:
	if isinstance(t, ProjectTarget):
	projects_to_clean.append(t.project_module())

	for t in results_of_main_targets:
	# Don't include roots or sources.
	targets_to_clean += b2.build.virtual_target.traverse(t)

	targets_to_clean = unique(targets_to_clean)

	is_child_cache_ = {}

	# Returns 'true' if 'project' is a child of 'current-project',
	# possibly indirect, or is equal to 'project'.
	# Returns 'false' otherwise.
	def is_child (project):

	r = is_child_cache_.get(project, None)
	if not r:
	if project in projects_to_clean:
	r = 1
	else:
	parent = manager.projects().attribute(project, "parent-module")
	if parent and parent != "user-config":
	r = is_child(parent)
	else:
	r = 0

	is_child_cache_[project] = r

	return r

	actual_targets = []
	for t in virtual_targets:
	actual_targets.append(t.actualize())


	bjam.call("NOTFILE", "all")
	bjam.call("DEPENDS", "all", actual_targets)

	if bjam_targets:
	bjam.call("UPDATE", ["<e>%s" % x for x in bjam_targets])
	elif clean_all:
	bjam.call("UPDATE", "clean-all")
	elif clean:
	to_clean = []
	for t in manager.virtual_targets().all_targets():
	p = t.project()

	# Remove only derived targets.
	if t.action() and \
	(t in targets_to_clean or is_child(p.project_module())):
	to_clean.append(t)

	to_clean_actual = [t.actualize() for t in to_clean]
	manager.engine().set_update_action('common.Clean', 'clean',
	to_clean_actual, None)

	bjam.call("UPDATE", "clean")

	else:
	bjam.call("UPDATE", "all")