| #!/usr/bin/python2.4 |
| # Copyright 2009, 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: 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: 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, 'rfile'): |
| continue # Not a file |
| n = n.rfile() |
| 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.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: 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: 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: 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: 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: 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: Should also have autobuild_projects option. If false, don't build |
| # them. |
| # TODO: 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: 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: 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, |
| }) |
