| #!/usr/bin/python |
| # Copyright (c) 2008 The Chromium Authors. All rights reserved. |
| # Use of this source code is governed by a BSD-style license that can be |
| # found in the LICENSE file. |
| """ |
| Commandline modification of Xcode project files |
| """ |
| |
| import sys |
| import os |
| import optparse |
| import re |
| import tempfile |
| import random |
| import subprocess |
| |
| random.seed() # Seed the generator |
| |
| |
| # All known project build path source tree path reference types |
| PBX_VALID_SOURCE_TREE_TYPES = ('"<group>"', |
| 'SOURCE_ROOT', |
| '"<absolute>"', |
| 'BUILT_PRODUCTS_DIR', |
| 'DEVELOPER_DIR', |
| 'SDKROOT', |
| 'CONFIGURATION_TEMP_DIR') |
| # Paths with some characters appear quoted |
| QUOTE_PATH_RE = re.compile('\s|-|\+') |
| |
| # Supported Xcode file types |
| EXTENSION_TO_XCODE_FILETYPE = { |
| '.h' : 'sourcecode.c.h', |
| '.c' : 'sourcecode.c.c', |
| '.cpp' : 'sourcecode.cpp.cpp', |
| '.cc' : 'sourcecode.cpp.cpp', |
| '.cxx' : 'sourcecode.cpp.cpp', |
| '.m' : 'sourcecode.c.objc', |
| '.mm' : 'sourcecode.c.objcpp', |
| } |
| |
| # File types that can be added to a Sources phase |
| SOURCES_XCODE_FILETYPES = ( 'sourcecode.c.c', |
| 'sourcecode.cpp.cpp', |
| 'sourcecode.c.objc', |
| 'sourcecode.c.objcpp' ) |
| |
| # Avoid inserting source files into these common Xcode group names. Because |
| # Xcode allows any names for these groups this list cannot be authoritative, |
| # but these are common names in the Xcode templates. |
| NON_SOURCE_GROUP_NAMES = ( 'Frameworks', |
| 'Resources', |
| 'Products', |
| 'Derived Sources', |
| 'Configurations', |
| 'Documentation', |
| 'Frameworks and Libraries', |
| 'External Frameworks and Libraries', |
| 'Libraries' ) |
| |
| |
| def NewUUID(): |
| """Create a new random Xcode UUID""" |
| __pychecker__ = 'unusednames=i' |
| elements = [] |
| for i in range(24): |
| elements.append(hex(random.randint(0, 15))[-1].upper()) |
| return ''.join(elements) |
| |
| def CygwinPathClean(path): |
| """Folks use Cygwin shells with standard Win32 Python which can't handle |
| Cygwin paths. Run everything through cygpath if we can (conveniently |
| cygpath does the right thing with normal Win32 paths). |
| """ |
| # Look for Unix-like path with Win32 Python |
| if sys.platform == 'win32' and path.startswith('/'): |
| cygproc = subprocess.Popen(('cygpath', '-a', '-w', path), |
| stdout=subprocess.PIPE) |
| (stdout_content, stderr_content) = cygproc.communicate() |
| return stdout_content.rstrip() |
| # Convert all paths to cygpaths if we're using cygwin python |
| if sys.platform == 'cygwin': |
| cygproc = subprocess.Popen(('cygpath', '-a', '-u', path), |
| stdout=subprocess.PIPE) |
| (stdout_content, stderr_content) = cygproc.communicate() |
| return stdout_content.rstrip() |
| # Fallthrough for all other cases |
| return path |
| |
| class XcodeProject(object): |
| """Class for reading/writing Xcode project files. |
| This is not a general parser or representation. It is restricted to just |
| the Xcode internal objects we need. |
| |
| Args: |
| path: Absolute path to Xcode project file (including project.pbxproj |
| filename) |
| Attributes: |
| path: Full path to the project.pbxproj file |
| name: Project name (wrapper directory basename without extension) |
| source_root_path: Absolute path for Xcode's SOURCE_ROOT |
| """ |
| |
| EXPECTED_PROJECT_HEADER_RE = re.compile( |
| r'^// !\$\*UTF8\*\$!\n' \ |
| '\{\n' \ |
| '\tarchiveVersion = 1;\n' \ |
| '\tclasses = \{\n' \ |
| '\t\};\n' \ |
| '\tobjectVersion = \d+;\n' \ |
| '\tobjects = \{\n' \ |
| '\n') |
| SECTION_BEGIN_RE = re.compile(r'^/\* Begin (.*) section \*/\n$') |
| SECTION_END_RE = re.compile(r'^/\* End (.*) section \*/\n$') |
| PROJECT_ROOT_OBJECT_RE = re.compile( |
| r'^\trootObject = ([0-9A-F]{24}) /\* Project object \*/;\n$') |
| |
| def __init__(self, path): |
| self.path = path |
| self.name = os.path.splitext(os.path.basename(os.path.dirname(path)))[0] |
| |
| # Load project. Ideally we would use plistlib, but sadly that only reads |
| # XML plists. A real parser with pyparsing |
| # (http://pyparsing.wikispaces.com/) might be another option, but for now |
| # we'll do the simple (?!?) thing. |
| project_fh = open(self.path, 'rU') |
| self._raw_content = project_fh.readlines() |
| project_fh.close() |
| |
| # Store and check header |
| if len(self._raw_content) < 8: |
| print >> sys.stderr, ''.join(self._raw_content) |
| raise RuntimeError('XcodeProject file "%s" too short' % path) |
| self._header = tuple(self._raw_content[:8]) |
| if not self.__class__.EXPECTED_PROJECT_HEADER_RE.match(''.join(self._header)): |
| print >> sys.stderr, ''.join(self._header) |
| raise RuntimeError('XcodeProject file "%s" wrong header' % path) |
| |
| # Find and store tail (some projects have additional whitespace at end) |
| self._tail = [] |
| for tail_line in reversed(self._raw_content): |
| self._tail.insert(0, tail_line) |
| if tail_line == '\t};\n': break |
| |
| # Ugly ugly project parsing, turn each commented section into a separate |
| # set of objects. For types we don't have a custom representation for, |
| # store the raw lines. |
| self._section_order = [] |
| self._sections = {} |
| parse_line_no = len(self._header) |
| while parse_line_no < (len(self._raw_content) - len(self._tail)): |
| section_header_match = self.__class__.SECTION_BEGIN_RE.match( |
| self._raw_content[parse_line_no]) |
| # Loop to next section header |
| if not section_header_match: |
| parse_line_no += 1 |
| continue |
| |
| section = section_header_match.group(1) |
| self._section_order.append(section) |
| self._sections[section] = [] |
| |
| # Advance to first line of the section |
| parse_line_no += 1 |
| |
| # Read in the section, using custom classes where we need them |
| section_end_match = self.__class__.SECTION_END_RE.match( |
| self._raw_content[parse_line_no]) |
| while not section_end_match: |
| # Unhandled lines |
| content = self._raw_content[parse_line_no] |
| # Sections we can parse line-by-line |
| if section in ('PBXBuildFile', 'PBXFileReference'): |
| content = eval('%s.FromContent(content)' % section) |
| # Multiline sections |
| elif section in ('PBXGroup', 'PBXVariantGroup', 'PBXProject', |
| 'PBXNativeTarget', 'PBXSourcesBuildPhase'): |
| # Accumulate lines |
| content_lines = [] |
| while 1: |
| content_lines.append(content) |
| if content == '\t\t};\n': break |
| parse_line_no += 1 |
| content = self._raw_content[parse_line_no] |
| content = eval('%s.FromContent(content_lines)' % section) |
| |
| self._sections[section].append(content) |
| parse_line_no += 1 |
| section_end_match = self.__class__.SECTION_END_RE.match( |
| self._raw_content[parse_line_no]) |
| # Validate section end |
| if section_header_match.group(1) != section: |
| raise RuntimeError( |
| 'XcodeProject parse, section "%s" ended inside section "%s"' % |
| (section_end_match.group(1), section)) |
| # Back around parse loop |
| |
| # Sanity overall group structure |
| if (not self._sections.has_key('PBXProject') or |
| len(self._sections['PBXProject']) != 1): |
| raise RuntimeError('PBXProject section insane') |
| root_obj_parsed = self.__class__.PROJECT_ROOT_OBJECT_RE.match( |
| self._tail[1]) |
| if not root_obj_parsed: |
| raise RuntimeError('XcodeProject unable to parse project root object:\n%s' |
| % self._tail[1]) |
| if root_obj_parsed.group(1) != self._sections['PBXProject'][0].uuid: |
| raise RuntimeError('XcodeProject root object does not match PBXProject') |
| self._root_group_uuid = self._sections['PBXProject'][0].main_group_uuid |
| |
| # Source root |
| self.source_root_path = os.path.abspath( |
| os.path.join( |
| # Directory that contains the project package |
| os.path.dirname(os.path.dirname(path)), |
| # Any relative path |
| self._sections['PBXProject'][0].project_root)) |
| |
| # Build the absolute paths of the groups with these helpers |
| def GroupAbsRealPath(*elements): |
| return os.path.abspath(os.path.realpath(os.path.join(*elements))) |
| def GroupPathRecurse(group, parent_path): |
| descend = False |
| if group.source_tree == '"<absolute>"': |
| group.abs_path = GroupAbsRealPath(group.path) |
| descend = True |
| elif group.source_tree == '"<group>"': |
| if group.path: |
| group.abs_path = GroupAbsRealPath(parent_path, group.path) |
| else: |
| group.abs_path = parent_path |
| descend = True |
| elif group.source_tree == 'SOURCE_ROOT': |
| if group.path: |
| group.abs_path = GroupAbsRealPath(self.source_root_path, group.path) |
| else: |
| group.abs_path = GroupAbsRealPath(self.source_root_path) |
| descend = True |
| if descend: |
| for child_uuid in group.child_uuids: |
| # Try a group first |
| found_uuid = False |
| for other_group in self._sections['PBXGroup']: |
| if other_group.uuid == child_uuid: |
| found_uuid = True |
| GroupPathRecurse(other_group, group.abs_path) |
| break |
| if self._sections.has_key('PBXVariantGroup'): |
| for other_group in self._sections['PBXVariantGroup']: |
| if other_group.uuid == child_uuid: |
| found_uuid = True |
| GroupPathRecurse(other_group, group.abs_path) |
| break |
| if not found_uuid: |
| for file_ref in self._sections['PBXFileReference']: |
| if file_ref.uuid == child_uuid: |
| found_uuid = True |
| if file_ref.source_tree == '"<absolute>"': |
| file_ref.abs_path = GroupAbsRealPath(file_ref.path) |
| elif group.source_tree == '"<group>"': |
| file_ref.abs_path = GroupAbsRealPath(group.abs_path, |
| file_ref.path) |
| elif group.source_tree == 'SOURCE_ROOT': |
| file_ref.abs_path = GroupAbsRealPath(self.source_root_path, |
| file_ref.path) |
| break |
| if not found_uuid: |
| raise RuntimeError('XcodeProject group descent failed to find %s' % |
| child_uuid) |
| self._root_group = None |
| for group in self._sections['PBXGroup']: |
| if group.uuid == self._root_group_uuid: |
| self._root_group = group |
| GroupPathRecurse(group, self.source_root_path) |
| if not self._root_group: |
| raise RuntimeError('XcodeProject failed to find root group by UUID') |
| |
| def FileContent(self): |
| """Generate and return the project file content as a list of lines""" |
| content = [] |
| content.extend(self._header[:-1]) |
| for section in self._section_order: |
| content.append('\n/* Begin %s section */\n' % section) |
| for section_content in self._sections[section]: |
| content.append(str(section_content)) |
| content.append('/* End %s section */\n' % section) |
| content.extend(self._tail) |
| return content |
| |
| def Update(self): |
| """Rewrite the project file in place with all updated metadata""" |
| __pychecker__ = 'no-deprecated' |
| # Not concerned with temp_path security here, just needed a unique name |
| temp_path = tempfile.mktemp(dir=os.path.dirname(self.path)) |
| outfile = open(temp_path, 'w') |
| outfile.writelines(self.FileContent()) |
| outfile.close() |
| # Rename is weird on Win32, see the docs, |
| os.unlink(self.path) |
| os.rename(temp_path, self.path) |
| |
| def NativeTargets(self): |
| """Obtain all PBXNativeTarget instances for this project |
| |
| Returns: |
| List of PBXNativeTarget instances |
| """ |
| if self._sections.has_key('PBXNativeTarget'): |
| return self._sections['PBXNativeTarget'] |
| else: |
| return [] |
| |
| def NativeTargetForName(self, name): |
| """Obtain the target with a given name. |
| |
| Args: |
| name: Target name |
| |
| Returns: |
| PBXNativeTarget instance or None |
| """ |
| for target in self.NativeTargets(): |
| if target.name == name: |
| return target |
| return None |
| |
| def FileReferences(self): |
| """Obtain all PBXFileReference instances for this project |
| |
| Returns: |
| List of PBXFileReference instances |
| """ |
| return self._sections['PBXFileReference'] |
| |
| def SourcesBuildPhaseForTarget(self, target): |
| """Obtain the PBXSourcesBuildPhase instance for a target. Xcode allows |
| only one PBXSourcesBuildPhase per target and each target has a unique |
| PBXSourcesBuildPhase. |
| |
| Args: |
| target: PBXNativeTarget instance |
| |
| Returns: |
| PBXSourcesBuildPhase instance |
| """ |
| sources_uuid = None |
| for i in range(len(target.build_phase_names)): |
| if target.build_phase_names[i] == 'Sources': |
| sources_uuid = target.build_phase_uuids[i] |
| break |
| if not sources_uuid: |
| raise RuntimeError('Missing PBXSourcesBuildPhase for target "%s"' % |
| target.name) |
| for sources_phase in self._sections['PBXSourcesBuildPhase']: |
| if sources_phase.uuid == sources_uuid: |
| return sources_phase |
| raise RuntimeError('Missing PBXSourcesBuildPhase for UUID "%s"' % |
| sources_uuid) |
| |
| def BuildFileForUUID(self, uuid): |
| """Look up a PBXBuildFile by UUID |
| |
| Args: |
| uuid: UUID of the PBXBuildFile to find |
| |
| Raises: |
| RuntimeError if no PBXBuildFile exists for |uuid| |
| |
| Returns: |
| PBXBuildFile instance |
| """ |
| for build_file in self._sections['PBXBuildFile']: |
| if build_file.uuid == uuid: |
| return build_file |
| raise RuntimeError('Missing PBXBuildFile for UUID "%s"' % uuid) |
| |
| def FileReferenceForUUID(self, uuid): |
| """Look up a PBXFileReference by UUID |
| |
| Args: |
| uuid: UUID of the PBXFileReference to find |
| |
| Raises: |
| RuntimeError if no PBXFileReference exists for |uuid| |
| |
| Returns: |
| PBXFileReference instance |
| """ |
| for file_ref in self._sections['PBXFileReference']: |
| if file_ref.uuid == uuid: |
| return file_ref |
| raise RuntimeError('Missing PBXFileReference for UUID "%s"' % uuid) |
| |
| def RemoveSourceFileReference(self, file_ref): |
| """Remove a source file's PBXFileReference from the project, cleaning up all |
| PBXGroup and PBXBuildFile references to that PBXFileReference and |
| furthermore, removing any PBXBuildFiles from all PBXNativeTarget source |
| lists. |
| |
| Args: |
| file_ref: PBXFileReference instance |
| |
| Raises: |
| RuntimeError if |file_ref| is not a source file reference in PBXBuildFile |
| """ |
| self._sections['PBXFileReference'].remove(file_ref) |
| # Clean up build files |
| removed_build_files = [] |
| for build_file in self._sections['PBXBuildFile']: |
| if build_file.file_ref_uuid == file_ref.uuid: |
| if build_file.type != 'Sources': |
| raise RuntimeError('Removing PBXBuildFile not of "Sources" type') |
| removed_build_files.append(build_file) |
| removed_build_file_uuids = [] |
| for build_file in removed_build_files: |
| removed_build_file_uuids.append(build_file.uuid) |
| self._sections['PBXBuildFile'].remove(build_file) |
| # Clean up source references to the removed build files |
| for source_phase in self._sections['PBXSourcesBuildPhase']: |
| removal_indexes = [] |
| for i in range(len(source_phase.file_uuids)): |
| if source_phase.file_uuids[i] in removed_build_file_uuids: |
| removal_indexes.append(i) |
| for removal_index in removal_indexes: |
| del source_phase.file_uuids[removal_index] |
| del source_phase.file_names[removal_index] |
| # Clean up group references |
| for group in self._sections['PBXGroup']: |
| removal_indexes = [] |
| for i in range(len(group.child_uuids)): |
| if group.child_uuids[i] == file_ref.uuid: |
| removal_indexes.append(i) |
| for removal_index in removal_indexes: |
| del group.child_uuids[removal_index] |
| del group.child_names[removal_index] |
| |
| def RelativeSourceRootPath(self, abs_path): |
| """Convert a path to one relative to the project's SOURCE_ROOT if possible. |
| Generally this follows Xcode semantics, that is, a path is only converted |
| if it is a subpath of SOURCE_ROOT. |
| |
| Args: |
| abs_path: Absolute path to convert |
| |
| Returns: |
| String SOURCE_ROOT relative path if possible or None if not relative |
| to SOURCE_ROOT. |
| """ |
| if abs_path.startswith(self.source_root_path + os.path.sep): |
| return abs_path[len(self.source_root_path + os.path.sep):] |
| else: |
| # Try to construct a relative path (bodged from ActiveState recipe |
| # 302594 since we can't assume Python 2.5 with os.path.relpath() |
| source_root_parts = self.source_root_path.split(os.path.sep) |
| target_parts = abs_path.split(os.path.sep) |
| # Guard against drive changes on Win32 and cygwin |
| if sys.platform == 'win32' and source_root_parts[0] <> target_parts[0]: |
| return None |
| if sys.platform == 'cygwin' and source_root_parts[2] <> target_parts[2]: |
| return None |
| for i in range(min(len(source_root_parts), len(target_parts))): |
| if source_root_parts[i] <> target_parts[i]: break |
| else: |
| i += 1 |
| rel_parts = [os.path.pardir] * (len(source_root_parts) - i) |
| rel_parts.extend(target_parts[i:]) |
| return os.path.join(*rel_parts) |
| |
| def RelativeGroupPath(self, abs_path): |
| """Convert a path to a group-relative path if possible |
| |
| Args: |
| abs_path: Absolute path to convert |
| |
| Returns: |
| Parent PBXGroup instance if possible or None |
| """ |
| needed_path = os.path.dirname(abs_path) |
| possible_groups = [ g for g in self._sections['PBXGroup'] |
| if g.abs_path == needed_path and |
| not g.name in NON_SOURCE_GROUP_NAMES ] |
| if len(possible_groups) < 1: |
| return None |
| elif len(possible_groups) == 1: |
| return possible_groups[0] |
| # Multiple groups match, try to find the best using some simple |
| # heuristics. Does only one group contain source? |
| groups_with_source = [] |
| for group in possible_groups: |
| for child_uuid in group.child_uuids: |
| try: |
| self.FileReferenceForUUID(child_uuid) |
| except RuntimeError: |
| pass |
| else: |
| groups_with_source.append(group) |
| break |
| if len(groups_with_source) == 1: |
| return groups_with_source[0] |
| # Is only one _not_ the root group? |
| non_root_groups = [ g for g in possible_groups |
| if g is not self._root_group ] |
| if len(non_root_groups) == 1: |
| return non_root_groups[0] |
| # Best guess |
| if len(non_root_groups): |
| return non_root_groups[0] |
| elif len(groups_with_source): |
| return groups_with_source[0] |
| else: |
| return possible_groups[0] |
| |
| def AddSourceFile(self, path): |
| """Add a source file to the project, attempting to position it |
| in the GUI group heirarchy reasonably. |
| |
| NOTE: Adding a source file does not add it to any targets |
| |
| Args: |
| path: Absolute path to the file to add |
| |
| Returns: |
| PBXFileReference instance for the newly added source. |
| """ |
| # Guess at file type |
| root, extension = os.path.splitext(path) |
| if EXTENSION_TO_XCODE_FILETYPE.has_key(extension): |
| source_type = EXTENSION_TO_XCODE_FILETYPE[extension] |
| else: |
| raise RuntimeError('Unknown source file extension "%s"' % extension) |
| |
| # Is group-relative possible for an existing group? |
| parent_group = self.RelativeGroupPath(os.path.abspath(path)) |
| if parent_group: |
| new_file_ref = PBXFileReference(NewUUID(), |
| os.path.basename(path), |
| source_type, |
| None, |
| os.path.basename(path), |
| '"<group>"', |
| None) |
| # Chrome tries to keep its lists name sorted, try to match |
| i = 0 |
| while i < len(parent_group.child_uuids): |
| # Only files are sorted, they keep groups at the top |
| try: |
| self.FileReferenceForUUID(parent_group.child_uuids[i]) |
| if new_file_ref.name.lower() < parent_group.child_names[i].lower(): |
| break |
| except RuntimeError: |
| pass # Must be a child group |
| i += 1 |
| parent_group.child_names.insert(i, new_file_ref.name) |
| parent_group.child_uuids.insert(i, new_file_ref.uuid) |
| # Add file ref uuid sorted |
| self._sections['PBXFileReference'].append(new_file_ref) |
| self._sections['PBXFileReference'].sort(cmp=lambda x,y: cmp(x.uuid, y.uuid)) |
| return new_file_ref |
| |
| # Group-relative failed, how about SOURCE_ROOT relative in the main group |
| src_rel_path = self.RelativeSourceRootPath(os.path.abspath(path)) |
| if src_rel_path: |
| src_rel_path = src_rel_path.replace('\\', '/') # Convert to Unix |
| new_file_ref = PBXFileReference(NewUUID(), |
| os.path.basename(path), |
| source_type, |
| None, |
| src_rel_path, |
| 'SOURCE_ROOT', |
| None) |
| self._root_group.child_uuids.append(new_file_ref.uuid) |
| self._root_group.child_names.append(new_file_ref.name) |
| # Add file ref uuid sorted |
| self._sections['PBXFileReference'].append(new_file_ref) |
| self._sections['PBXFileReference'].sort(cmp=lambda x,y: cmp(x.uuid, y.uuid)) |
| return new_file_ref |
| |
| # Win to Unix absolute paths probably not practical |
| raise RuntimeError('Could not construct group or source PBXFileReference ' |
| 'for path "%s"' % path) |
| |
| def AddSourceFileToSourcesBuildPhase(self, source_ref, source_phase): |
| """Add a PBXFileReference to a PBXSourcesBuildPhase, creating a new |
| PBXBuildFile as needed. |
| |
| Args: |
| source_ref: PBXFileReference instance appropriate for use in |
| PBXSourcesBuildPhase |
| source_phase: PBXSourcesBuildPhase instance |
| """ |
| # Prevent duplication |
| for source_uuid in source_phase.file_uuids: |
| build_file = self.BuildFileForUUID(source_uuid) |
| if build_file.file_ref_uuid == source_ref.uuid: |
| return |
| # Create PBXBuildFile |
| new_build_file = PBXBuildFile(NewUUID(), |
| source_ref.name, |
| 'Sources', |
| source_ref.uuid, |
| '') |
| # Add to build file list (uuid sorted) |
| self._sections['PBXBuildFile'].append(new_build_file) |
| self._sections['PBXBuildFile'].sort(cmp=lambda x,y: cmp(x.uuid, y.uuid)) |
| # Add to sources phase list (name sorted) |
| i = 0 |
| while i < len(source_phase.file_names): |
| if source_ref.name.lower() < source_phase.file_names[i].lower(): |
| break |
| i += 1 |
| source_phase.file_names.insert(i, new_build_file.name) |
| source_phase.file_uuids.insert(i, new_build_file.uuid) |
| |
| |
| class PBXProject(object): |
| """Class for PBXProject data section of an Xcode project file. |
| |
| Attributes: |
| uuid: Project UUID |
| main_group_uuid: UUID of the top-level PBXGroup |
| project_root: Relative path from project file wrapper to source_root_path |
| """ |
| |
| PBXPROJECT_HEADER_RE = re.compile( |
| r'^\t\t([0-9A-F]{24}) /\* Project object \*/ = {\n$') |
| PBXPROJECT_MAIN_GROUP_RE = re.compile( |
| r'^\t\t\tmainGroup = ([0-9A-F]{24})(?: /\* .* \*/)?;\n$') |
| PBXPROJECT_ROOT_RE = re.compile( |
| r'^\t\t\tprojectRoot = (.*);\n$') |
| |
| @classmethod |
| def FromContent(klass, content_lines): |
| header_parsed = klass.PBXPROJECT_HEADER_RE.match(content_lines[0]) |
| if not header_parsed: |
| raise RuntimeError('PBXProject unable to parse header content:\n%s' |
| % content_lines[0]) |
| main_group_uuid = None |
| project_root = '' |
| for content_line in content_lines: |
| group_parsed = klass.PBXPROJECT_MAIN_GROUP_RE.match(content_line) |
| if group_parsed: |
| main_group_uuid = group_parsed.group(1) |
| root_parsed = klass.PBXPROJECT_ROOT_RE.match(content_line) |
| if root_parsed: |
| project_root = root_parsed.group(1) |
| if project_root.startswith('"'): |
| project_root = project_root[1:-1] |
| if not main_group_uuid: |
| raise RuntimeError('PBXProject missing main group') |
| return klass(content_lines, header_parsed.group(1), |
| main_group_uuid, project_root) |
| |
| def __init__(self, raw_lines, uuid, main_group_uuid, project_root): |
| self.uuid = uuid |
| self._raw_lines = raw_lines |
| self.main_group_uuid = main_group_uuid |
| self.project_root = project_root |
| |
| def __str__(self): |
| return ''.join(self._raw_lines) |
| |
| |
| class PBXBuildFile(object): |
| """Class for PBXBuildFile data from an Xcode project file. |
| |
| Attributes: |
| uuid: UUID for this instance |
| name: Basename of the build file |
| type: 'Sources' or 'Frameworks' |
| file_ref_uuid: UUID of the PBXFileReference for this file |
| """ |
| |
| PBXBUILDFILE_LINE_RE = re.compile( |
| r'^\t\t([0-9A-F]{24}) /\* (.+) in (.+) \*/ = ' |
| '{isa = PBXBuildFile; fileRef = ([0-9A-F]{24}) /\* (.+) \*/; (.*)};\n$') |
| |
| @classmethod |
| def FromContent(klass, content_line): |
| parsed = klass.PBXBUILDFILE_LINE_RE.match(content_line) |
| if not parsed: |
| raise RuntimeError('PBXBuildFile unable to parse content:\n%s' |
| % content_line) |
| if parsed.group(2) != parsed.group(5): |
| raise RuntimeError('PBXBuildFile name mismatch "%s" vs "%s"' % |
| (parsed.group(2), parsed.group(5))) |
| if not parsed.group(3) in ('Sources', 'Frameworks', |
| 'Resources', 'CopyFiles', |
| 'Headers', 'Copy Into Framework', |
| 'Rez', 'Copy Generated Headers'): |
| raise RuntimeError('PBXBuildFile unknown type "%s"' % parsed.group(3)) |
| return klass(parsed.group(1), parsed.group(2), parsed.group(3), |
| parsed.group(4), parsed.group(6)) |
| |
| def __init__(self, uuid, name, type, file_ref_uuid, raw_extras): |
| self.uuid = uuid |
| self.name = name |
| self.type = type |
| self.file_ref_uuid = file_ref_uuid |
| self._raw_extras = raw_extras |
| |
| def __str__(self): |
| return '\t\t%s /* %s in %s */ = ' \ |
| '{isa = PBXBuildFile; fileRef = %s /* %s */; %s};\n' % ( |
| self.uuid, self.name, self.type, self.file_ref_uuid, self.name, |
| self._raw_extras) |
| |
| |
| class PBXFileReference(object): |
| """Class for PBXFileReference data from an Xcode project file. |
| |
| Attributes: |
| uuid: UUID for this instance |
| name: Basename of the file |
| file_type: current active file type (explicit or assumed) |
| path: source_tree relative path (or absolute if source_tree is absolute) |
| source_tree: Source tree type (see PBX_VALID_SOURCE_TREE_TYPES) |
| abs_path: Absolute path to the file |
| """ |
| PBXFILEREFERENCE_HEADER_RE = re.compile( |
| r'^\t\t([0-9A-F]{24}) /\* (.+) \*/ = {isa = PBXFileReference; ') |
| PBXFILEREFERENCE_FILETYPE_RE = re.compile( |
| r' (lastKnownFileType|explicitFileType) = ([^\;]+); ') |
| PBXFILEREFERENCE_PATH_RE = re.compile(r' path = ([^\;]+); ') |
| PBXFILEREFERENCE_SOURCETREE_RE = re.compile(r' sourceTree = ([^\;]+); ') |
| |
| @classmethod |
| def FromContent(klass, content_line): |
| header_parsed = klass.PBXFILEREFERENCE_HEADER_RE.match(content_line) |
| if not header_parsed: |
| raise RuntimeError('PBXFileReference unable to parse header content:\n%s' |
| % content_line) |
| type_parsed = klass.PBXFILEREFERENCE_FILETYPE_RE.search(content_line) |
| if not type_parsed: |
| raise RuntimeError('PBXFileReference unable to parse type content:\n%s' |
| % content_line) |
| if type_parsed.group(1) == 'lastKnownFileType': |
| last_known_type = type_parsed.group(2) |
| explicit_type = None |
| else: |
| last_known_type = None |
| explicit_type = type_parsed.group(2) |
| path_parsed = klass.PBXFILEREFERENCE_PATH_RE.search(content_line) |
| if not path_parsed: |
| raise RuntimeError('PBXFileReference unable to parse path content:\n%s' |
| % content_line) |
| tree_parsed = klass.PBXFILEREFERENCE_SOURCETREE_RE.search(content_line) |
| if not tree_parsed: |
| raise RuntimeError( |
| 'PBXFileReference unable to parse source tree content:\n%s' |
| % content_line) |
| return klass(header_parsed.group(1), header_parsed.group(2), |
| last_known_type, explicit_type, path_parsed.group(1), |
| tree_parsed.group(1), content_line) |
| |
| def __init__(self, uuid, name, last_known_file_type, explicit_file_type, |
| path, source_tree, raw_line): |
| self.uuid = uuid |
| self.name = name |
| self._last_known_file_type = last_known_file_type |
| self._explicit_file_type = explicit_file_type |
| if explicit_file_type: |
| self.file_type = explicit_file_type |
| else: |
| self.file_type = last_known_file_type |
| self.path = path |
| self.source_tree = source_tree |
| self.abs_path = None |
| self._raw_line = raw_line |
| |
| def __str__(self): |
| # Raw available? |
| if self._raw_line: return self._raw_line |
| # Construct our own |
| if self._last_known_file_type: |
| print_file_type = 'lastKnownFileType = %s; ' % self._last_known_file_type |
| elif self._explicit_file_type: |
| print_file_type = 'explicitFileType = %s; ' % self._explicit_file_type |
| else: |
| raise RuntimeError('No known file type for stringification') |
| name_attribute = '' |
| if self.name != self.path: |
| name_attribute = 'name = %s; ' % self.name |
| print_path = self.path |
| if QUOTE_PATH_RE.search(print_path): |
| print_path = '"%s"' % print_path |
| return '\t\t%s /* %s */ = ' \ |
| '{isa = PBXFileReference; ' \ |
| 'fileEncoding = 4; ' \ |
| '%s' \ |
| '%s' \ |
| 'path = %s; sourceTree = %s; };\n' % ( |
| self.uuid, self.name, print_file_type, |
| name_attribute, print_path, self.source_tree) |
| |
| |
| class PBXGroup(object): |
| """Class for PBXGroup data from an Xcode project file. |
| |
| Attributes: |
| uuid: UUID for this instance |
| name: Group (folder) name |
| path: source_tree relative path (or absolute if source_tree is absolute) |
| source_tree: Source tree type (see PBX_VALID_SOURCE_TREE_TYPES) |
| abs_path: Absolute path to the group |
| child_uuids: Ordered list of PBXFileReference UUIDs |
| child_names: Ordered list of PBXFileReference names |
| """ |
| |
| PBXGROUP_HEADER_RE = re.compile(r'^\t\t([0-9A-F]{24}) (?:/\* .* \*/ )?= {\n$') |
| PBXGROUP_FIELD_RE = re.compile(r'^\t\t\t(.*) = (.*);\n$') |
| PBXGROUP_CHILD_RE = re.compile(r'^\t\t\t\t([0-9A-F]{24}) /\* (.*) \*/,\n$') |
| |
| @classmethod |
| def FromContent(klass, content_lines): |
| # Header line |
| header_parsed = klass.PBXGROUP_HEADER_RE.match(content_lines[0]) |
| if not header_parsed: |
| raise RuntimeError('PBXGroup unable to parse header content:\n%s' |
| % content_lines[0]) |
| name = None |
| path = '' |
| source_tree = None |
| tab_width = None |
| uses_tabs = None |
| indent_width = None |
| child_uuids = [] |
| child_names = [] |
| # Parse line by line |
| content_line_no = 0 |
| while 1: |
| content_line_no += 1 |
| content_line = content_lines[content_line_no] |
| if content_line == '\t\t};\n': break |
| if content_line == '\t\t\tisa = PBXGroup;\n': continue |
| if content_line == '\t\t\tisa = PBXVariantGroup;\n': continue |
| # Child groups |
| if content_line == '\t\t\tchildren = (\n': |
| content_line_no += 1 |
| content_line = content_lines[content_line_no] |
| while content_line != '\t\t\t);\n': |
| child_parsed = klass.PBXGROUP_CHILD_RE.match(content_line) |
| if not child_parsed: |
| raise RuntimeError('PBXGroup unable to parse child content:\n%s' |
| % content_line) |
| child_uuids.append(child_parsed.group(1)) |
| child_names.append(child_parsed.group(2)) |
| content_line_no += 1 |
| content_line = content_lines[content_line_no] |
| continue # Back to top of loop on end of children |
| # Other fields |
| field_parsed = klass.PBXGROUP_FIELD_RE.match(content_line) |
| if not field_parsed: |
| raise RuntimeError('PBXGroup unable to parse field content:\n%s' |
| % content_line) |
| if field_parsed.group(1) == 'name': |
| name = field_parsed.group(2) |
| elif field_parsed.group(1) == 'path': |
| path = field_parsed.group(2) |
| elif field_parsed.group(1) == 'sourceTree': |
| if not field_parsed.group(2) in PBX_VALID_SOURCE_TREE_TYPES: |
| raise RuntimeError('PBXGroup unknown source tree type "%s"' |
| % field_parsed.group(2)) |
| source_tree = field_parsed.group(2) |
| elif field_parsed.group(1) == 'tabWidth': |
| tab_width = field_parsed.group(2) |
| elif field_parsed.group(1) == 'usesTabs': |
| uses_tabs = field_parsed.group(2) |
| elif field_parsed.group(1) == 'indentWidth': |
| indent_width = field_parsed.group(2) |
| else: |
| raise RuntimeError('PBXGroup unknown field "%s"' |
| % field_parsed.group(1)) |
| if path and path.startswith('"'): |
| path = path[1:-1] |
| if name and name.startswith('"'): |
| name = name[1:-1] |
| return klass(header_parsed.group(1), name, path, source_tree, child_uuids, |
| child_names, tab_width, uses_tabs, indent_width) |
| |
| def __init__(self, uuid, name, path, source_tree, child_uuids, child_names, |
| tab_width, uses_tabs, indent_width): |
| self.uuid = uuid |
| self.name = name |
| self.path = path |
| self.source_tree = source_tree |
| self.child_uuids = child_uuids |
| self.child_names = child_names |
| self.abs_path = None |
| # Semantically I'm not sure these aren't an error, but they |
| # appear in some projects |
| self._tab_width = tab_width |
| self._uses_tabs = uses_tabs |
| self._indent_width = indent_width |
| |
| def __str__(self): |
| if self.name: |
| header_comment = '/* %s */ ' % self.name |
| elif self.path: |
| header_comment = '/* %s */ ' % self.path |
| else: |
| header_comment = '' |
| if self.name: |
| if QUOTE_PATH_RE.search(self.name): |
| name_attribute = '\t\t\tname = "%s";\n' % self.name |
| else: |
| name_attribute = '\t\t\tname = %s;\n' % self.name |
| else: |
| name_attribute = '' |
| if self.path: |
| if QUOTE_PATH_RE.search(self.path): |
| path_attribute = '\t\t\tpath = "%s";\n' % self.path |
| else: |
| path_attribute = '\t\t\tpath = %s;\n' % self.path |
| else: |
| path_attribute = '' |
| child_lines = [] |
| for x in range(len(self.child_uuids)): |
| child_lines.append('\t\t\t\t%s /* %s */,\n' % |
| (self.child_uuids[x], self.child_names[x])) |
| children = ''.join(child_lines) |
| tab_width_attribute = '' |
| if self._tab_width: |
| tab_width_attribute = '\t\t\ttabWidth = %s;\n' % self._tab_width |
| uses_tabs_attribute = '' |
| if self._uses_tabs: |
| uses_tabs_attribute = '\t\t\tusesTabs = %s;\n' % self._uses_tabs |
| indent_width_attribute = '' |
| if self._indent_width: |
| indent_width_attribute = '\t\t\tindentWidth = %s;\n' % self._indent_width |
| return '\t\t%s %s= {\n' \ |
| '\t\t\tisa = %s;\n' \ |
| '\t\t\tchildren = (\n' \ |
| '%s' \ |
| '\t\t\t);\n' \ |
| '%s' \ |
| '%s' \ |
| '%s' \ |
| '\t\t\tsourceTree = %s;\n' \ |
| '%s' \ |
| '%s' \ |
| '\t\t};\n' % ( |
| self.uuid, header_comment, |
| self.__class__.__name__, |
| children, |
| indent_width_attribute, |
| name_attribute, |
| path_attribute, self.source_tree, |
| tab_width_attribute, uses_tabs_attribute) |
| |
| |
| class PBXVariantGroup(PBXGroup): |
| pass |
| |
| |
| class PBXNativeTarget(object): |
| """Class for PBXNativeTarget data from an Xcode project file. |
| |
| Attributes: |
| name: Target name |
| build_phase_uuids: Ordered list of build phase UUIDs |
| build_phase_names: Ordered list of build phase names |
| |
| NOTE: We do not have wrapper classes for all build phase data types! |
| """ |
| |
| PBXNATIVETARGET_HEADER_RE = re.compile( |
| r'^\t\t([0-9A-F]{24}) /\* (.*) \*/ = {\n$') |
| PBXNATIVETARGET_BUILD_PHASE_RE = re.compile( |
| r'^\t\t\t\t([0-9A-F]{24}) /\* (.*) \*/,\n$') |
| |
| @classmethod |
| def FromContent(klass, content_lines): |
| header_parsed = klass.PBXNATIVETARGET_HEADER_RE.match(content_lines[0]) |
| if not header_parsed: |
| raise RuntimeError('PBXNativeTarget unable to parse header content:\n%s' |
| % content_lines[0]) |
| build_phase_uuids = [] |
| build_phase_names = [] |
| content_line_no = 0 |
| while 1: |
| content_line_no += 1 |
| content_line = content_lines[content_line_no] |
| if content_line == '\t\t};\n': break |
| if content_line == '\t\t\tisa = PBXNativeTarget;\n': continue |
| # Build phases groups |
| if content_line == '\t\t\tbuildPhases = (\n': |
| content_line_no += 1 |
| content_line = content_lines[content_line_no] |
| while content_line != '\t\t\t);\n': |
| phase_parsed = klass.PBXNATIVETARGET_BUILD_PHASE_RE.match( |
| content_line) |
| if not phase_parsed: |
| raise RuntimeError( |
| 'PBXNativeTarget unable to parse build phase content:\n%s' |
| % content_line) |
| build_phase_uuids.append(phase_parsed.group(1)) |
| build_phase_names.append(phase_parsed.group(2)) |
| content_line_no += 1 |
| content_line = content_lines[content_line_no] |
| break # Don't care about the rest of the content |
| return klass(content_lines, header_parsed.group(2), build_phase_uuids, |
| build_phase_names) |
| |
| def __init__(self, raw_lines, name, build_phase_uuids, build_phase_names): |
| self._raw_lines = raw_lines |
| self.name = name |
| self.build_phase_uuids = build_phase_uuids |
| self.build_phase_names = build_phase_names |
| |
| def __str__(self): |
| return ''.join(self._raw_lines) |
| |
| |
| class PBXSourcesBuildPhase(object): |
| """Class for PBXSourcesBuildPhase data from an Xcode project file. |
| |
| Attributes: |
| uuid: UUID for this instance |
| build_action_mask: Xcode magic mask constant |
| run_only_for_deployment_postprocessing: deployment postprocess flag |
| file_uuids: Ordered list of PBXBuildFile UUIDs |
| file_names: Ordered list of PBXBuildFile names (basename) |
| """ |
| |
| PBXSOURCESBUILDPHASE_HEADER_RE = re.compile( |
| r'^\t\t([0-9A-F]{24}) /\* Sources \*/ = {\n$') |
| PBXSOURCESBUILDPHASE_FIELD_RE = re.compile(r'^\t\t\t(.*) = (.*);\n$') |
| PBXSOURCESBUILDPHASE_FILE_RE = re.compile( |
| r'^\t\t\t\t([0-9A-F]{24}) /\* (.*) in Sources \*/,\n$') |
| |
| @classmethod |
| def FromContent(klass, content_lines): |
| header_parsed = klass.PBXSOURCESBUILDPHASE_HEADER_RE.match(content_lines[0]) |
| if not header_parsed: |
| raise RuntimeError( |
| 'PBXSourcesBuildPhase unable to parse header content:\n%s' |
| % content_lines[0]) |
| # Parse line by line |
| build_action_mask = None |
| run_only_for_deployment_postprocessing = None |
| file_uuids = [] |
| file_names = [] |
| content_line_no = 0 |
| while 1: |
| content_line_no += 1 |
| content_line = content_lines[content_line_no] |
| if content_line == '\t\t};\n': break |
| if content_line == '\t\t\tisa = PBXSourcesBuildPhase;\n': continue |
| # Files |
| if content_line == '\t\t\tfiles = (\n': |
| content_line_no += 1 |
| content_line = content_lines[content_line_no] |
| while content_line != '\t\t\t);\n': |
| file_parsed = klass.PBXSOURCESBUILDPHASE_FILE_RE.match(content_line) |
| if not file_parsed: |
| raise RuntimeError( |
| 'PBXSourcesBuildPhase unable to parse file content:\n%s' |
| % content_line) |
| file_uuids.append(file_parsed.group(1)) |
| file_names.append(file_parsed.group(2)) |
| content_line_no += 1 |
| content_line = content_lines[content_line_no] |
| continue # Back to top of loop on end of files list |
| # Other fields |
| field_parsed = klass.PBXSOURCESBUILDPHASE_FIELD_RE.match(content_line) |
| if not field_parsed: |
| raise RuntimeError( |
| 'PBXSourcesBuildPhase unable to parse field content:\n%s' |
| % content_line) |
| if field_parsed.group(1) == 'buildActionMask': |
| build_action_mask = field_parsed.group(2) |
| elif field_parsed.group(1) == 'runOnlyForDeploymentPostprocessing': |
| run_only_for_deployment_postprocessing = field_parsed.group(2) |
| else: |
| raise RuntimeError('PBXSourcesBuildPhase unknown field "%s"' |
| % field_parsed.group(1)) |
| return klass(header_parsed.group(1), build_action_mask, |
| run_only_for_deployment_postprocessing, |
| file_uuids, file_names) |
| |
| def __init__(self, uuid, build_action_mask, |
| run_only_for_deployment_postprocessing, |
| file_uuids, file_names): |
| self.uuid = uuid |
| self.build_action_mask = build_action_mask |
| self.run_only_for_deployment_postprocessing = \ |
| run_only_for_deployment_postprocessing |
| self.file_uuids = file_uuids |
| self.file_names = file_names |
| |
| def __str__(self): |
| file_lines = [] |
| for x in range(len(self.file_uuids)): |
| file_lines.append('\t\t\t\t%s /* %s in Sources */,\n' % |
| (self.file_uuids[x], self.file_names[x])) |
| files = ''.join(file_lines) |
| return '\t\t%s /* Sources */ = {\n' \ |
| '\t\t\tisa = PBXSourcesBuildPhase;\n' \ |
| '\t\t\tbuildActionMask = %s;\n' \ |
| '\t\t\tfiles = (\n' \ |
| '%s' \ |
| '\t\t\t);\n' \ |
| '\t\t\trunOnlyForDeploymentPostprocessing = %s;\n' \ |
| '\t\t};\n' % ( |
| self.uuid, self.build_action_mask, files, |
| self.run_only_for_deployment_postprocessing) |
| |
| |
| def Usage(optparse): |
| optparse.print_help() |
| print '\n' \ |
| 'Commands:\n' \ |
| ' list_native_targets: List Xcode "native" (source compilation)\n' \ |
| ' targets by name.\n' \ |
| ' list_target_sources: List project-relative source files in the\n' \ |
| ' specified Xcode "native" target.\n' \ |
| ' remove_source [sourcefile ...]: Remove the specified source files\n' \ |
| ' from every target in the project (target is ignored).\n' \ |
| ' add_source [sourcefile ...]: Add the specified source files\n' \ |
| ' to the specified target.\n' |
| sys.exit(2) |
| |
| |
| def Main(): |
| # Use argument structure like xcodebuild commandline |
| option_parser = optparse.OptionParser( |
| usage='usage: %prog -p projectname [ -t targetname ] ' \ |
| '<command> [...]', |
| add_help_option=False) |
| option_parser.add_option( |
| '-h', '--help', action='store_true', dest='help', |
| default=False, help=optparse.SUPPRESS_HELP) |
| option_parser.add_option( |
| '-p', '--project', action='store', type='string', |
| dest='project', metavar='projectname', |
| help='Manipulate the project specified by projectname.') |
| option_parser.add_option( |
| '-t', '--target', action='store', type='string', |
| dest='target', metavar='targetname', |
| help='Manipulate the target specified by targetname.') |
| (options, args) = option_parser.parse_args() |
| |
| # Since we have more elaborate commands, handle help |
| if options.help: |
| Usage(option_parser) |
| |
| # Xcode project file |
| if not options.project: |
| option_parser.error('Xcode project file must be specified.') |
| project_path = os.path.abspath(CygwinPathClean(options.project)) |
| if project_path.endswith('.xcodeproj'): |
| project_path = os.path.join(project_path, 'project.pbxproj') |
| if not project_path.endswith(os.sep + 'project.pbxproj'): |
| option_parser.error('Invalid Xcode project file path \"%s\"' % project_path) |
| if not os.path.exists(project_path): |
| option_parser.error('Missing Xcode project file \"%s\"' % project_path) |
| |
| # Construct project object |
| project = XcodeProject(project_path) |
| |
| # Switch on command |
| |
| # List native target names (default command) |
| if len(args) < 1 or args[0] == 'list_native_targets': |
| # Ape xcodebuild output |
| target_names = [] |
| for target in project.NativeTargets(): |
| target_names.append(target.name) |
| print 'Information about project "%s"\n Native Targets:\n %s' % ( |
| project.name, |
| '\n '.join(target_names)) |
| |
| if len(args) < 1: |
| # Be friendly and print some hints for further actions. |
| print |
| print 'To add or remove files from given target, run:' |
| print '\txcodebodge.py -p <project> -t <target> add_source <file_name>' |
| print '\txcodebodge.py -p <project> -t <target> remove_source <file_name>' |
| |
| # List files in a native target |
| elif args[0] == 'list_target_sources': |
| if len(args) != 1: |
| option_parser.error('list_target_sources takes no arguments') |
| if not options.target: |
| option_parser.error('list_target_sources requires a target') |
| # Validate target and get list of files |
| target = project.NativeTargetForName(options.target) |
| if not target: |
| option_parser.error('No native target named "%s"' % options.target) |
| sources_phase = project.SourcesBuildPhaseForTarget(target) |
| target_files = [] |
| for source_uuid in sources_phase.file_uuids: |
| build_file = project.BuildFileForUUID(source_uuid) |
| file_ref = project.FileReferenceForUUID(build_file.file_ref_uuid) |
| pretty_path = project.RelativeSourceRootPath(file_ref.abs_path) |
| if pretty_path: |
| target_files.append(pretty_path) |
| else: |
| target_files.append(file_ref.abs_path) |
| # Ape xcodebuild output |
| print 'Information about project "%s" target "%s"\n' \ |
| ' Files:\n %s' % (project.name, options.target, |
| '\n '.join(target_files)) |
| |
| # Remove source files |
| elif args[0] == 'remove_source': |
| if len(args) < 2: |
| option_parser.error('remove_source needs one or more source files') |
| if options.target: |
| option_parser.error( |
| 'remove_source does not support removal from a single target') |
| for source_path in args[1:]: |
| source_path = CygwinPathClean(source_path) |
| found = False |
| for file_ref in project.FileReferences(): |
| # Try undecorated path, abs_path and our prettified paths |
| if (file_ref.path == source_path or ( |
| file_ref.abs_path and ( |
| file_ref.abs_path == os.path.abspath(source_path) or |
| project.RelativeSourceRootPath(file_ref.abs_path) == source_path))): |
| # Found a matching file ref, remove it |
| found = True |
| project.RemoveSourceFileReference(file_ref) |
| if not found: |
| option_parser.error('No matching source file "%s"' % source_path) |
| project.Update() |
| |
| # Add source files |
| elif args[0] == 'add_source': |
| if len(args) < 2: |
| option_parser.error('add_source needs one or more source files') |
| if not options.target: |
| option_parser.error('add_source requires a target') |
| # Look for the target we want to add too. |
| target = project.NativeTargetForName(options.target) |
| if not target: |
| option_parser.error('No native target named "%s"' % options.target) |
| # Get the sources build phase |
| sources_phase = project.SourcesBuildPhaseForTarget(target) |
| # Loop new sources |
| for source_path in args[1:]: |
| source_path = CygwinPathClean(source_path) |
| if not os.path.exists(os.path.abspath(source_path)): |
| option_parser.error('File "%s" not found' % source_path) |
| # Don't generate duplicate file references if we don't need them |
| source_ref = None |
| for file_ref in project.FileReferences(): |
| # Try undecorated path, abs_path and our prettified paths |
| if (file_ref.path == source_path or ( |
| file_ref.abs_path and ( |
| file_ref.abs_path == os.path.abspath(source_path) or |
| project.RelativeSourceRootPath(file_ref.abs_path) == source_path))): |
| source_ref = file_ref |
| break |
| if not source_ref: |
| # Create a new source file ref |
| source_ref = project.AddSourceFile(os.path.abspath(source_path)) |
| # Add the new source file reference to the target if its a safe type |
| if source_ref.file_type in SOURCES_XCODE_FILETYPES: |
| project.AddSourceFileToSourcesBuildPhase(source_ref, sources_phase) |
| project.Update() |
| |
| # Private sanity check. On an unmodified project make sure our output is |
| # the same as the input |
| elif args[0] == 'parse_sanity': |
| if ''.join(project.FileContent()) != ''.join(project._raw_content): |
| option_parser.error('Project rewrite sanity fail "%s"' % project.path) |
| |
| else: |
| Usage(option_parser) |
| |
| |
| if __name__ == '__main__': |
| Main() |
