#!/usr/bin/python2.4
# Copyright 2008, Google Inc.
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions are
# met:
#
# * Redistributions of source code must retain the above copyright
# notice, this list of conditions and the following disclaimer.
# * Redistributions in binary form must reproduce the above
# copyright notice, this list of conditions and the following disclaimer
# in the documentation and/or other materials provided with the
# distribution.
# * Neither the name of Google Inc. nor the names of its
# contributors may be used to endorse or promote products derived from
# this software without specific prior written permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
"""Visual Studio solution output of component targets for SCons."""
import copy
import md5
import os
import sys
import xml.dom
import xml.dom.minidom
import SCons
#------------------------------------------------------------------------------
def MakeGuid(name, seed='component_targets_msvs'):
"""Returns a GUID for the specified target name.
Args:
name: Target name.
seed: Seed for MD5 hash.
Returns:
A GUID-line string calculated from the name and seed.
This generates something which looks like a GUID, but depends only on the
name and seed. This means the same name/seed will always generate the same
GUID, so that projects and solutions which refer to each other can explicitly
determine the GUID to refer to explicitly. It also means that the GUID will
not change when the project for a target is rebuilt.
"""
# Calculate a MD5 signature for the seed and name.
d = md5.new(str(seed) + str(name)).hexdigest().upper()
# Convert most of the signature to GUID form (discard the rest)
guid = ('{' + d[:8] + '-' + d[8:12] + '-' + d[12:16] + '-' + d[16:20]
+ '-' + d[20:32] + '}')
return guid
#------------------------------------------------------------------------------
def GetGuidAndNameFromVSProject(project_path):
"""Reads the GUID from a Visual Studio project file.
Args:
project_path: Path to the Visual Studio project file.
Returns:
The GUID string from the file.
The project name from the file.
"""
doc = xml.dom.minidom.parse(project_path)
try:
n_root = doc.documentElement
if n_root.nodeName != 'VisualStudioProject':
raise SCons.Errors.UserError('%s is not a Visual Studio project.' %
project_path)
return (
str(n_root.attributes['ProjectGUID'].nodeValue),
str(n_root.attributes['Name'].nodeValue),
)
finally:
# Clean up doc
doc.unlink()
#------------------------------------------------------------------------------
class VSProjectWriter(object):
"""Visual Studio XML project writer."""
def __init__(self, project_path):
"""Initializes the project.
Args:
project_path: Path to the project file.
"""
self.project_path = project_path
self.doc = None
def Create(self, name):
"""Creates the project document.
Args:
name: Name of the project.
"""
self.name = name
self.guid = MakeGuid(name)
# Create XML doc
xml_impl = xml.dom.getDOMImplementation()
self.doc = xml_impl.createDocument(None, 'VisualStudioProject', None)
# Add attributes to root element
self.n_root = self.doc.documentElement
self.n_root.setAttribute('ProjectType', 'Visual C++')
self.n_root.setAttribute('Version', '8.00')
self.n_root.setAttribute('Name', self.name)
self.n_root.setAttribute('ProjectGUID', self.guid)
self.n_root.setAttribute('RootNamespace', self.name)
self.n_root.setAttribute('Keyword', 'MakeFileProj')
# Add platform list
n_platform = self.doc.createElement('Platforms')
self.n_root.appendChild(n_platform)
n = self.doc.createElement('Platform')
n.setAttribute('Name', 'Win32')
n_platform.appendChild(n)
# Add empty ToolFiles section
self.n_root.appendChild(self.doc.createElement('ToolFiles'))
# Add configurations section
self.n_configs = self.doc.createElement('Configurations')
self.n_root.appendChild(self.n_configs)
# Add files section
self.n_files = self.doc.createElement('Files')
self.n_root.appendChild(self.n_files)
# Add empty Globals section
self.n_root.appendChild(self.doc.createElement('Globals'))
def AddConfig(self, name, attrs, tool_attrs):
"""Adds a configuration to the project.
Args:
name: Configuration name.
attrs: Dict of configuration attributes.
tool_attrs: Dict of tool attributes.
"""
# Add configuration node
n_config = self.doc.createElement('Configuration')
n_config.setAttribute('Name', '%s|Win32' % name)
n_config.setAttribute('ConfigurationType', '0')
for k, v in attrs.items():
n_config.setAttribute(k, v)
self.n_configs.appendChild(n_config)
# Add tool node
n_tool = self.doc.createElement('Tool')
n_tool.setAttribute('Name', 'VCNMakeTool')
n_tool.setAttribute('IncludeSearchPath', '')
n_tool.setAttribute('ForcedIncludes', '')
n_tool.setAttribute('AssemblySearchPath', '')
n_tool.setAttribute('ForcedUsingAssemblies', '')
n_tool.setAttribute('CompileAsManaged', '')
n_tool.setAttribute('PreprocessorDefinitions', '')
for k, v in tool_attrs.items():
n_tool.setAttribute(k, v)
n_config.appendChild(n_tool)
def _WalkFolders(self, folder_dict, parent):
"""Recursively walks the folder tree.
Args:
folder_dict: Dict of folder entries. Entry is
either subdir_name:subdir_dict or relative_path_to_file:None.
parent: Parent node (folder node for that dict)
"""
entries = folder_dict.keys()
entries.sort()
for e in entries:
if folder_dict[e]:
# Folder
n_subfolder = self.doc.createElement('Filter')
n_subfolder.setAttribute('Name', e)
parent.appendChild(n_subfolder)
self._WalkFolders(folder_dict[e], n_subfolder)
else:
# File
n_file = self.doc.createElement('File')
n_file.setAttribute('RelativePath', e)
parent.appendChild(n_file)
def AddFiles(self, name, files_dict):
"""Adds files to the project.
Args:
name: Name of the folder. If None, files/folders will be added directly
to the files list.
files_dict: A dict of files / folders.
Within the files_dict:
* A file entry is relative_path:None
* A folder entry is folder_name:files_dict, where files_dict is another
dict of this form.
"""
# Create subfolder if necessary
if name:
n_folder = self.doc.createElement('Filter')
n_folder.setAttribute('Name', name)
self.n_files.appendChild(n_folder)
else:
n_folder = self.n_files
# Recursively add files to the folder
self._WalkFolders(files_dict, n_folder)
def Write(self):
"""Writes the project file."""
f = open(self.project_path, 'wt')
self.doc.writexml(f, encoding='Windows-1252', addindent=' ', newl='\n')
f.close()
#------------------------------------------------------------------------------
def ComponentVSProjectBuilder(target, source, env):
"""Visual Studio project builder.
Args:
target: Destination file.
source: List of sources to be added to the target.
env: Environment context.
Returns:
Zero if successful.
"""
source = source # Silence gpylint
target_name = env['TARGET_NAME']
project_file = target[0].path
project_to_main = env.RelativePath(target[0].dir, env.Dir('$MAIN_DIR'),
sep='/')
env_hammer_bat = env.Clone(VS_PROJECT_TO_MAIN_DIR=project_to_main)
hammer_bat = env_hammer_bat.subst('$COMPONENT_VS_PROJECT_SCRIPT_PATH', raw=1)
vsp = VSProjectWriter(project_file)
vsp.Create(target_name)
# Add configuration per build mode supported by this target
target_path = env['TARGET_PATH']
for mode, path in target_path.items():
attrs = {}
attrs['OutputDirectory'] = '$(ProjectDir)/%s/%s/out' % (mode, target_name)
attrs['IntermediateDirectory'] = ('$(ProjectDir)/%s/%s/tmp' %
(mode, target_name))
tool_attrs = {}
if path:
tool_attrs['Output'] = env.RelativePath(target[0].dir,
env.Entry(path), sep='/')
build_cmd = '%s --mode=%s %s' % (hammer_bat, mode, target_name)
clean_cmd = '%s --mode=%s -c %s' % (hammer_bat, mode, target_name)
tool_attrs['BuildCommandLine'] = build_cmd
tool_attrs['CleanCommandLine'] = clean_cmd
tool_attrs['ReBuildCommandLine'] = clean_cmd + ' && ' + build_cmd
vsp.AddConfig(mode, attrs, tool_attrs)
# TODO(rspangler): Fill in files - at least, the .scons file invoking the
# target.
# Write project
vsp.Write()
return 0
def ComponentVSProject(self, target_name, **kwargs):
"""Visual Studio project pseudo-builder for the specified target.
Args:
self: Environment context.
target_name: Name of the target.
kwargs: Optional keyword arguments override environment variables in the
derived environment used to create the project.
Returns:
A list of output nodes.
"""
# Builder only works on Windows
if sys.platform not in ('win32', 'cygwin'):
return []
# Clone environment and add keyword args
env = self.Clone()
for k, v in kwargs.items():
env[k] = v
# Save the target name
env['TARGET_NAME'] = target_name
# Extract the target properties and save in the environment for use by the
# real builder.
t = GetTargets().get(target_name)
env['TARGET_PATH'] = {}
if t:
for mode, mode_properties in t.mode_properties.items():
# Since the target path is what Visual Studio will run, use the EXE
# property in preference to TARGET_PATH.
target_path = mode_properties.get('EXE',
mode_properties.get('TARGET_PATH'))
env.Append(TARGET_PATH={mode: target_path})
else:
# No modes declared for this target. Could be a custom alias created by
# a SConscript, rather than a component builder. Assume it can be built in
# all modes, but produces no output.
for mode in GetTargetModes():
env.Append(TARGET_PATH={mode: None})
# Call the real builder
return env.ComponentVSProjectBuilder(
'$COMPONENT_VS_PROJECT_DIR/${TARGET_NAME}', [])
#------------------------------------------------------------------------------
class SourceWalker(object):
"""Iterator for walking a node tree and collecting sources.
This is depth-first, children are visited before the parent. The object
can be initialized with any node, and returns the next node on the descent
with each Next() call.
This class does not get caught in node cycles caused, for example, by C
header file include loops.
Based on SCons.Node.Walker.
"""
def __init__(self, node, seen, print_interval = 1000):
"""Initializes the source walker.
Args:
node: Node to start walk from.
seen: Set to add seen nodes to, if not None.
print_interval: Interval in nodes examined at which to print a progress
indicator.
"""
self.interval = print_interval
# Put node on stack
self.stack = [node]
# Scan for node's children, then copy them to node.wkids
node.wkids = copy.copy(node.children(scan=1))
# Keep track of nodes we've seen (returned)
if seen is None:
seen = set()
self.seen = seen
# Add node to history for cycle detection
self.history = set()
self.history.add(node)
# We've seen one node now
self.nodes_examined = 1
self.unique_nodes = 1
def Next(self):
"""Get the next node for this walk of the tree.
Returns:
The next node, or None if no more nodes.
This function is intentionally iterative, not recursive, to sidestep any
issues of stack size limitations.
"""
while self.stack:
if self.stack[-1].wkids:
# Node has children we haven't examined, so iterate into the first
# child
node = self.stack[-1].wkids.pop(0)
if not self.stack[-1].wkids:
# No more children of this node
self.stack[-1].wkids = None
self.nodes_examined += 1
if self.interval and not self.nodes_examined % self.interval:
self.PrintProgress()
if (node not in self.history) and (node not in self.seen):
# Haven't hit a cycle or a node we've already seen
node.wkids = copy.copy(node.children(scan=1))
self.stack.append(node)
self.history.add(node)
else:
# Coming back from iterating, so return the next node on the stack.
node = self.stack.pop()
self.history.remove(node)
self.seen.add(node)
self.unique_nodes += 1
return node
return None
def PrintProgress(self):
"""Prints a progress indicator."""
print ' Examined %d nodes, found %d unique...' % (
self.nodes_examined, self.unique_nodes)
def WalkAll(self):
"""Walks all nodes in the the tree."""
while self.Next():
pass
if self.interval:
self.PrintProgress()
def ComponentVSSourceProjectBuilder(target, source, env):
"""Visual Studio source project builder.
Args:
target: Destination file.
source: List of sources to be added to the target.
env: Environment context.
Returns:
Zero if successful.
"""
source = source # Silence gpylint
target_name = env['PROJECT_NAME']
project_file = target[0].path
project_dir = target[0].dir
# Get list of suffixes to include
suffixes = env.SubstList2('$COMPONENT_VS_SOURCE_SUFFIXES')
# Convert source folders to absolute paths
folders = []
for f in env['COMPONENT_VS_SOURCE_FOLDERS']:
# (folder name, folder abspath, dict of contents)
folders.append((f[0], env.Dir(f[1]).abspath, {}))
# TODO(rspangler): Additional enhancements:
# * Should be able to specify paths in folder name (i.e., foo/bar) and
# create the nested folder nodes ('foo' and 'bar')
# * Should be tolerant of a folder being specified more than once with
# the same name (probably necessary to support nested folder nodes anyway)
# Can probably accomplish both of those by creating a parent fodler dict and
# calling WalkFolders() only once.
# Create a temporary solution alias to point to all the targets, so we can
# make a single call to SourceWalker()
tmp_alias = env.Alias('vs_source_project_' + target_name,
map(env.Alias, env['COMPONENT_VS_SOURCE_TARGETS']))
# Scan all targets and add unique nodes to set of sources
print ' Scanning dependency tree ...'
all_srcs = set()
walker = SourceWalker(tmp_alias[0], all_srcs)
walker.WalkAll()
# Walk all sources and build directory trees
print ' Building source tree...'
for n in all_srcs:
if not hasattr(n, 'isfile') or not n.isfile():
continue # Not a file
if n.has_builder():
continue # Not a leaf node
if n.suffix not in suffixes:
continue # Not a file type we include
path = n.rfile().abspath
for f in folders:
if path.startswith(f[1]):
if f[0] is None:
# Folder name of None is a filter
break
relpath = path[len(f[1]) + 1:].split(os.sep)
folder_dict = f[2]
# Recursively add subdirs
for pathseg in relpath[:-1]:
if pathseg not in folder_dict:
folder_dict[pathseg] = {}
folder_dict = folder_dict[pathseg]
# Add file to last subdir. No dict, since this isn't a subdir
folder_dict[env.RelativePath(project_dir, path)] = None
break
print ' Writing project file...'
vsp = VSProjectWriter(project_file)
vsp.Create(target_name)
# One configuration for all build modes
vsp.AddConfig('all', {}, {})
# Add files
for f in folders:
if f[0] is None:
continue # Skip filters
vsp.AddFiles(f[0], f[2])
vsp.Write()
return 0
def ComponentVSSourceProject(self, project_name, target_names, **kwargs):
"""Visual Studio source project pseudo-builder.
Args:
self: Environment context.
project_name: Name of the project.
target_names: List of target names to include source for.
kwargs: Optional keyword arguments override environment variables in the
derived environment used to create the project.
Returns:
A list of output nodes.
"""
# Builder only works on Windows
if sys.platform not in ('win32', 'cygwin'):
return []
# Clone environment and add keyword args
env = self.Clone()
for k, v in kwargs.items():
env[k] = v
# Save the project name and targets
env['PROJECT_NAME'] = project_name
env['COMPONENT_VS_SOURCE_TARGETS'] = target_names
# Call the real builder
return env.ComponentVSSourceProjectBuilder(
'$COMPONENT_VS_PROJECT_DIR/${PROJECT_NAME}', [])
#------------------------------------------------------------------------------
def FindSources(env, dest, source, suffixes=None):
"""Recursively finds sources and adds them to the destination set.
Args:
env: Environment context.
dest: Set to add source nodes to.
source: Source file(s) to find. May be a string, Node, or a list of
mixed strings or Nodes. Strings will be passed through env.Glob() to
evaluate wildcards. If a source evaluates to a directory, the entire
directory will be recursively added.
suffixes: List of suffixes to include. If not None, only files with these
suffixes will be added to dest.
"""
for source_entry in env.Flatten(source):
if type(source_entry) == str:
# Search for matches for each source entry
source_nodes = env.Glob(source_entry)
else:
# Source entry is already a file or directory node; no need to glob it
source_nodes = [source_entry]
for s in source_nodes:
if str(s.__class__) == 'SCons.Node.FS.Dir':
# Recursively search subdir. Since glob('*') doesn't match dot files,
# also glob('.*').
FindSources(env, dest, [s.abspath + '/*', s.abspath + '/.*'], suffixes)
elif suffixes and s.suffix in suffixes:
dest.add(s)
def ComponentVSDirProjectBuilder(target, source, env):
"""Visual Studio directory project builder.
Args:
target: Destination file.
source: List of sources to be added to the target.
env: Environment context.
Returns:
Zero if successful.
"""
source = source # Silence gpylint
target_name = env['PROJECT_NAME']
project_file = target[0].path
project_dir = target[0].dir
# Convert source folders to absolute paths
folders = []
for f in env['COMPONENT_VS_SOURCE_FOLDERS']:
# (folder name, folder abspath, dict of contents)
folders.append((f[0], env.Dir(f[1]).abspath, {}))
# Recursively scan source directories
print ' Scanning directories for source...'
all_srcs = set()
FindSources(env, all_srcs, env['PROJECT_SOURCES'],
suffixes=env.SubstList2('$COMPONENT_VS_SOURCE_SUFFIXES'))
# Walk all sources and build directory trees
print ' Building source tree...'
for n in all_srcs:
# Map addRepository'd source to its real location.
path = n.rfile().abspath
for f in folders:
if path.startswith(f[1]):
if f[0] is None:
# Folder name of None is a filter
break
relpath = path[len(f[1]) + 1:].split(os.sep)
folder_dict = f[2]
# Recursively add subdirs
for pathseg in relpath[:-1]:
if pathseg not in folder_dict:
folder_dict[pathseg] = {}
folder_dict = folder_dict[pathseg]
# Add file to last subdir. No dict, since this isn't a subdir
folder_dict[env.RelativePath(project_dir, path)] = None
break
print ' Writing project file...'
vsp = VSProjectWriter(project_file)
vsp.Create(target_name)
# One configuration for all build modes
vsp.AddConfig('all', {}, {})
# Add files
for f in folders:
if f[0] is None:
continue # Skip filters
vsp.AddFiles(f[0], f[2])
vsp.Write()
return 0
def ComponentVSDirProject(self, project_name, source, **kwargs):
"""Visual Studio directory project pseudo-builder.
Args:
self: Environment context.
project_name: Name of the project.
source: List of source files and/or directories.
kwargs: Optional keyword arguments override environment variables in the
derived environment used to create the project.
Returns:
A list of output nodes.
"""
# Builder only works on Windows
if sys.platform not in ('win32', 'cygwin'):
return []
# Clone environment and add keyword args
env = self.Clone()
for k, v in kwargs.items():
env[k] = v
# Save the project name and sources
env['PROJECT_NAME'] = project_name
env['PROJECT_SOURCES'] = source
# Call the real builder
return env.ComponentVSDirProjectBuilder(
'$COMPONENT_VS_PROJECT_DIR/${PROJECT_NAME}', [])
#------------------------------------------------------------------------------
def ComponentVSSolutionBuilder(target, source, env):
"""Visual Studio solution builder.
Args:
target: Destination file.
source: List of sources to be added to the target.
env: Environment context.
Returns:
Zero if successful.
"""
source = source # Silence gpylint
solution_file = target[0].path
projects = env['SOLUTION_PROJECTS']
folders = env['SOLUTION_FOLDERS']
# Scan externally-generated projects
external_projects = []
for p in source:
guid, name = GetGuidAndNameFromVSProject(p.abspath)
external_projects.append((p, name, guid))
f = open(solution_file, 'wt')
f.write('Microsoft Visual Studio Solution File, Format Version 9.00\n')
f.write('# Visual Studio 2005\n')
# Projects generated by ComponentVSSolution()
for p in projects:
project_file = env.File(
'$COMPONENT_VS_PROJECT_DIR/%s$COMPONENT_VS_PROJECT_SUFFIX' % p)
f.write('Project("%s") = "%s", "%s", "%s"\nEndProject\n' % (
'{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}', # External makefile GUID
p, # Project name
env.RelativePath(target[0].dir, project_file), # Path to project file
MakeGuid(p), # Project GUID
))
# Projects generated elsewhere
for p, name, guid in external_projects:
f.write('Project("%s") = "%s", "%s", "%s"\nEndProject\n' % (
# TODO(rspangler): What if this project isn't type external makefile?
# How to tell what type it is?
'{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}', # External makefile GUID
name, # Project name
env.RelativePath(target[0].dir, p), # Path to project file
guid, # Project GUID
))
# Folders from build groups
# TODO(rspangler): Currently no way to add external project (specified in
# sources) to a solution folder.
for folder in folders:
f.write('Project("%s") = "%s", "%s", "%s"\nEndProject\n' % (
'{2150E333-8FDC-42A3-9474-1A3956D46DE8}', # Solution folder GUID
folder, # Folder name
folder, # Folder name (again)
# Use a different seed so the folder won't get the same GUID as a
# project.
MakeGuid(folder, seed='folder'), # Project GUID
))
f.write('\tGlobalSection(SolutionConfigurationPlatforms) = preSolution\n')
for mode in GetTargetModes():
f.write('\t\t%s|Win32 = %s|Win32\n' % (mode, mode))
f.write('\tEndGlobalSection\n')
# Determine which projects should be enabled
# TODO(rspangler): This is somewhat clunky. DEFAULT_TARGETS is global, and
# what we really need is something mode-specific. In theory we could make
# this a mode-specific dict rather than a list, but that'd also be a pain to
# populate.
# These variable names are also getting REALLY long. Perhaps we should
# define shorter ones (with the default value redirecting to the longer
# ones for legacy compatibility).
enable_projects = env.SubstList2('$COMPONENT_VS_ENABLED_PROJECTS')
f.write('\tGlobalSection(ProjectConfigurationPlatforms) = postSolution\n')
# Projects generated by ComponentVSSolution()
for p in projects:
for mode in GetTargetModes():
f.write('\t\t%s.%s|Win32.ActiveCfg = %s|Win32\n' % (
MakeGuid(p), # Project GUID
mode, # Solution build configuration
mode, # Project build config for that solution config
))
t = GetTargets().get(p)
# Determine if project should be enabled in this mode
enabled = t and mode in t.mode_properties
if enable_projects and p not in enable_projects:
# Enable list specified, but target isn't in it
# TODO(rspangler): Since we env.Default(scons-out) elsewhere, this
# likely causes all projects to be disabled by default. But that's
# realistically better than enabling them all...
enabled = False
if enabled:
# Target can be built in this mode
f.write('\t\t%s.%s|Win32.Build.0 = %s|Win32\n' % (
MakeGuid(p), # Project GUID
mode, # Solution build configuration
mode, # Project build config for that solution config
))
# Projects generated elsewhere
for p, name, guid in external_projects:
for mode in GetTargetModes():
f.write('\t\t%s.%s|Win32.ActiveCfg = %s|Win32\n' % (
guid, # Project GUID
mode, # Solution build configuration
mode, # Project build config for that solution config
))
if name in enable_projects or not enable_projects:
# Build target in this mode
f.write('\t\t%s.%s|Win32.Build.0 = %s|Win32\n' % (
guid, # Project GUID
mode, # Solution build configuration
mode, # Project build config for that solution config
))
f.write('\tEndGlobalSection\n')
f.write('\tGlobalSection(SolutionProperties) = preSolution\n')
f.write('\t\tHideSolutionNode = FALSE\n')
f.write('\tEndGlobalSection\n')
if folders:
f.write('\tGlobalSection(NestedProjects) = preSolution\n')
for p, folder in projects.items():
f.write('\t\t%s = %s\n' % (MakeGuid(p), MakeGuid(folder, seed='folder')))
f.write('\tEndGlobalSection\n')
f.write('EndGlobal\n')
f.close()
return 0
def ComponentVSSolution(self, solution_name, target_names, projects=None,
**kwargs):
"""Visual Studio solution pseudo-builder.
Args:
self: Environment context.
solution_name: Name of the solution.
target_names: Names of targets or target groups to include in the solution.
This will automatically build projects for them.
projects: List of aditional projects not generated by this solution to
include in the solution.
kwargs: Optional keyword arguments override environment variables in the
derived environment used to create the solution.
Returns:
The list of output nodes.
"""
# TODO(rspangler): Should have option to build source project also. Perhaps
# select using a --source_project option, since it needs to use gather_inputs
# to scan the DAG and will blow up the null build time.
# TODO(rspangler): Should also have autobuild_projects option. If false,
# don't build them.
# TODO(rspangler): Should also be able to specify a target group directly
# (i.e. 'run_all_tests')
# Builder only works on Windows
if sys.platform not in ('win32', 'cygwin'):
return []
# Clone environment and add keyword args
env = self.Clone()
for k, v in kwargs.items():
env[k] = v
# Save the target name
env['SOLUTION_NAME'] = solution_name
# Get list of targets to make projects for. At this point we haven't
# determined whether they're groups or targets.
target_names = env.SubstList2(target_names)
env['SOLUTION_TARGETS'] = target_names
# Save the default targets list as an environment variable
env['COMPONENT_VS_SCONS_DEFAULT_TARGETS'] = SCons.Script.DEFAULT_TARGETS
# Expand target_names into project names, and create project-to-folder
# mappings
project_names = {}
folders = []
if target_names:
# Expand target_names into project names
for target in target_names:
if target in GetTargetGroups():
# Add target to folders
folders.append(target)
# Add all project_names in the group
for t in GetTargetGroups()[target].GetTargetNames():
project_names[t] = target
elif target in GetTargets():
# Just a target name
project_names[target] = None
else:
print 'Warning: ignoring unknown target "%s"' % target
else:
# No target names specified, so use all projects
for t in GetTargets():
project_names[t] = None
env['SOLUTION_FOLDERS'] = folders
env['SOLUTION_PROJECTS'] = project_names
# Call the real builder
out_nodes = env.ComponentVSSolutionBuilder(
'$COMPONENT_VS_SOLUTION_DIR/${SOLUTION_NAME}', projects or [])
# Call the real builder for the projects we generate
for p in project_names:
out_nodes += env.ComponentVSProject(p)
# Add the solution target
# TODO(rspangler): Should really defer the rest of the work above, since
# otherwise we can't build a solution which has a target to rebuild itself.
env.Alias('all_solutions', env.Alias(solution_name, out_nodes))
# TODO(rspangler): To rebuild the solution properly, need to override its
# project configuration so it only has '--mode=all' (or some other way of
# setting the subset of modes which it should use to rebuild itself).
# Rebuilding with the property below will strip it down to just the current
# build mode, which isn't what we want.
# Let component_targets know this target is available in the current mode
#self.SetTargetProperty(solution_name, TARGET_PATH=out_nodes[0])
return out_nodes
#------------------------------------------------------------------------------
def generate(env):
# NOTE: SCons requires the use of this name, which fails gpylint.
"""SCons entry point for this tool."""
# Add pseudo-builders to set up the project and solution builders. These
# need to be available on all platforms so that SConscripts which reference
# them will work.
env.AddMethod(ComponentVSDirProject)
env.AddMethod(ComponentVSProject)
env.AddMethod(ComponentVSSolution)
env.AddMethod(ComponentVSSourceProject)
# If not on Windows, don't do anything else
if sys.platform not in ('win32', 'cygwin'):
return
# Include tools we need
env.Tool('gather_inputs')
env.SetDefault(
COMPONENT_VS_PROJECT_DIR='$COMPONENT_VS_SOLUTION_DIR/projects',
COMPONENT_VS_PROJECT_SCRIPT_NAME = 'hammer.bat',
COMPONENT_VS_PROJECT_SCRIPT_PATH = (
'$$(ProjectDir)/$VS_PROJECT_TO_MAIN_DIR/'
'$COMPONENT_VS_PROJECT_SCRIPT_NAME'),
COMPONENT_VS_PROJECT_SUFFIX='.vcproj',
COMPONENT_VS_SOLUTION_DIR='$DESTINATION_ROOT/solution',
COMPONENT_VS_SOLUTION_SUFFIX='.sln',
COMPONENT_VS_ENABLED_PROJECTS=['$COMPONENT_VS_SCONS_DEFAULT_TARGETS'],
COMPONENT_VS_SOURCE_SUFFIXES=['$CPPSUFFIXES', '.rc', '.scons'],
COMPONENT_VS_SOURCE_FOLDERS=[('source', '$MAIN_DIR')],
)
AddTargetGroup('all_solutions', 'solutions can be built')
# Add builders
vcprojaction = SCons.Script.Action(ComponentVSProjectBuilder, varlist=[
'COMPONENT_VS_PROJECT_SCRIPT_PATH',
'TARGET_NAME',
'TARGET_PATH',
])
vcprojbuilder = SCons.Script.Builder(
action=vcprojaction,
suffix='$COMPONENT_VS_PROJECT_SUFFIX')
source_vcproj_action = SCons.Script.Action(
ComponentVSSourceProjectBuilder, varlist=[
'COMPONENT_VS_SOURCE_FOLDERS',
'COMPONENT_VS_SOURCE_SUFFIXES',
'COMPONENT_VS_SOURCE_TARGETS',
])
source_vcproj_builder = SCons.Script.Builder(
action=source_vcproj_action,
suffix='$COMPONENT_VS_PROJECT_SUFFIX')
dir_vcproj_action = SCons.Script.Action(
ComponentVSDirProjectBuilder, varlist=[
'COMPONENT_VS_SOURCE_FOLDERS',
'COMPONENT_VS_SOURCE_SUFFIXES',
'PROJECT_SOURCES',
])
dir_vcproj_builder = SCons.Script.Builder(
action=dir_vcproj_action,
suffix='$COMPONENT_VS_PROJECT_SUFFIX')
slnaction = SCons.Script.Action(ComponentVSSolutionBuilder, varlist=[
'COMPONENT_VS_ENABLED_PROJECTS',
'SOLUTION_FOLDERS',
'SOLUTION_PROJECTS',
'SOLUTION_TARGETS',
])
slnbuilder = SCons.Script.Builder(
action=slnaction,
suffix='$COMPONENT_VS_SOLUTION_SUFFIX')
env.Append(BUILDERS={
'ComponentVSDirProjectBuilder': dir_vcproj_builder,
'ComponentVSProjectBuilder': vcprojbuilder,
'ComponentVSSolutionBuilder': slnbuilder,
'ComponentVSSourceProjectBuilder': source_vcproj_builder,
})