Note that it can be handy to look at the project files output by the tests

to diagnose problems. The easiest way to do that is by kindly asking the

test driver to leave the temporary directories it creates in-place.

| `all_dependent_settings` | A dictionary of settings to be applied to all dependents of the target, transitively. This includes direct dependents and the entire set of their dependents, and so on. This section may contain anything found within a `target` dictionary, except `configurations`, `target_name`, and `type` sections. Compare `direct_dependent_settings` and `link_settings`. |

| `configurations` | A list of dictionaries defining build configurations for the target. See the "Configurations" section below. |

| `copies` | A list of copy actions to perform. See the "Copies" section below. |

| `dependencies` | A list of targets on which this target depends. Targets in other `.gyp` files are specified as `../path/to/other.gyp:target_we_want`. |

| `direct_dependent_settings` | A dictionary of settings to be applied to other targets that depend on this target. These settings will only be applied to direct dependents. This section may contain anything found within a `target` dictionary, except `configurations`, `target_name`, and `type` sections. Compare with `all_dependent_settings` and `link_settings`. |

| `include_dirs` | A list of include directories to be passed on the command line to the C/C++ compiler (via `-I` or `/I` options). |

Conditionals may appear within any dictionary in a `.gyp` file. There

are two tpes of conditionals, which differ only in the timing of their

dependencies have been computed.

A conditional section is introduced with a `conditions` or

Verifies that the output string contains all of the "lines" in the specified

list of lines. In practice, the lines can be any substring and need not be

Verifies that the output string does _not_ contain any of the "lines" in the

specified list of lines. In practice, the lines can be any substring and need

the test fails.

Verifies that the output string contains at least one of the "lines" in the

specified list of lines. In practice, the lines can be any substring and need

the test fails.

`'conditions'`: A list of condition specifications that can modify the

contents of the items in the global dictionary defined by this `.gyp`

above example, the most common use of a `conditions` section in the

top-level dictionary is to add platform-specific targets to the

`targets` list.

already in the `conditions` for the target), and you can't change the

file name, there are two patterns that can be used.

dictionary within the `targets` list. Add an appropriate `conditions`

section to exclude the specific files name:

Adding a library often involves updating multiple `.gyp` files, adding

file), and updating targets in the other `.gyp` files that depend on

(link with) the new library.

`direct_dependent_settings` block.

Note that these settings will likely need to be replicated in the

with the same options. This does not prevent the target from defining

additional options for its "internal" use when compiling its own source

files. (In the above example, these are the `LOCAL_DEFINE_FOR_LIBBAR`

) & set(self._root_targets)

if matching_test_targets_contains_all:

# Remove any of the targets for all that were not explicitly supplied,

matching_test_targets = list(

set(matching_test_targets) & set(test_targets_no_all)

)

clean_cflags = []

include_paths = []

def __init__(self, target_list):

cmake_target_base_names_seen = set()

for qualified_target in target_list:

if cmake_target_base_name not in cmake_target_base_names_seen:

cmake_target_base_names_seen.add(cmake_target_base_name)

else:

def CreateCMakeTargetName(self, qualified_target):

base_name = CreateCMakeTargetBaseName(qualified_target)

return CreateCMakeTargetFullName(qualified_target)

return base_name

LINK_COMMANDS_MAC = """\

LINK_COMMANDS_ANDROID = """\

def WriteRootHeaderSuffixRules(writer):

# Since this target depends on binary and resources which are in

# nested subfolders, the framework directory will be older than

# its dependencies usually. To prevent this rule from executing

# update the time on the framework directory.

self.WriteLn("\t@touch -c %s" % QuoteSpaces(self.output))

"PLI.host": PLI_host,

}

if flavor == "mac":

header_params.update(

{

"flock": flock_command,

header_params.update(

{

"copy_archive_args": copy_archive_arguments,

"flock_index": 2,

}

)

{

"copy_archive_args": copy_archive_arguments,

"link_commands": LINK_COMMANDS_AIX,

"flock_index": 2,

}

)

{

"copy_archive_args": copy_archive_arguments,

"link_commands": LINK_COMMANDS_OS400,

"flock_index": 2,

}

)

def _ToolSetOrAppend(tools, tool_name, setting, value, only_if_unset=False):

# TODO(bradnelson): ugly hack, fix this more generally!!!

if "Directories" in setting or "Dependencies" in setting:

value = value.replace("/", "\\")

else:

value = [i.replace("/", "\\") for i in value]

if tool.get(setting):

if only_if_unset:

return

tool[setting] += value

else:

raise TypeError(

# Collapse settings with lists.

settings_fixed = {}

for setting, value in settings.items():

if (

tool == "VCLinkerTool" and setting == "AdditionalDependencies"

) or setting == "AdditionalOptions":

# Convert to folders recursively.

children = []

for folder, contents in bucket.items():

folder_children = _DictsToFolders(

os.path.join(base_path, folder), contents, flat

)

# Recursively explorer the tree of dicts looking for projects which are

# the sole item in a folder which has the same name as the project. Bring

# such projects up one level.

return node[next(iter(node))]

return node

for child in node:

node[child] = _CollapseSingles(child, node[child])

# Walk down from the top until we hit a folder that has more than one entry.

# In practice, this strips the top-level "src/" dir from the hierarchy in

# the solution.

root = root[next(iter(root))]

# Collapse singles.

root = _CollapseSingles("", root)

num_configurations = len(spec["configurations"])

def GetEdges(node):

# This happens to be easier in this case, since a variable's

# definition contains all variables it references in a single string.

edges = set()

def _GetValueFormattedForMSBuild(tool_name, name, value):

# For some settings, VS2010 does not automatically extends the settings

# TODO(jeanluc) Is this what we want?

if name in [