"Fossies" - the Fresh Open Source Software Archive

Member "Atom/resources/app/apm/node_modules/node-gyp/gyp/pylib/gyp/generator/android.py" (7 Feb 2017, 45344 Bytes) of archive /windows/misc/atom-windows.zip:


As a special service "Fossies" has tried to format the requested source page into HTML format using (guessed) Python source code syntax highlighting (style: standard) with prefixed line numbers. Alternatively you can here view or download the uninterpreted source code file.

    1 # Copyright (c) 2012 Google Inc. All rights reserved.
    2 # Use of this source code is governed by a BSD-style license that can be
    3 # found in the LICENSE file.
    4 
    5 # Notes:
    6 #
    7 # This generates makefiles suitable for inclusion into the Android build system
    8 # via an Android.mk file. It is based on make.py, the standard makefile
    9 # generator.
   10 #
   11 # The code below generates a separate .mk file for each target, but
   12 # all are sourced by the top-level GypAndroid.mk.  This means that all
   13 # variables in .mk-files clobber one another, and furthermore that any
   14 # variables set potentially clash with other Android build system variables.
   15 # Try to avoid setting global variables where possible.
   16 
   17 import gyp
   18 import gyp.common
   19 import gyp.generator.make as make  # Reuse global functions from make backend.
   20 import os
   21 import re
   22 import subprocess
   23 
   24 generator_default_variables = {
   25   'OS': 'android',
   26   'EXECUTABLE_PREFIX': '',
   27   'EXECUTABLE_SUFFIX': '',
   28   'STATIC_LIB_PREFIX': 'lib',
   29   'SHARED_LIB_PREFIX': 'lib',
   30   'STATIC_LIB_SUFFIX': '.a',
   31   'SHARED_LIB_SUFFIX': '.so',
   32   'INTERMEDIATE_DIR': '$(gyp_intermediate_dir)',
   33   'SHARED_INTERMEDIATE_DIR': '$(gyp_shared_intermediate_dir)',
   34   'PRODUCT_DIR': '$(gyp_shared_intermediate_dir)',
   35   'SHARED_LIB_DIR': '$(builddir)/lib.$(TOOLSET)',
   36   'LIB_DIR': '$(obj).$(TOOLSET)',
   37   'RULE_INPUT_ROOT': '%(INPUT_ROOT)s',  # This gets expanded by Python.
   38   'RULE_INPUT_DIRNAME': '%(INPUT_DIRNAME)s',  # This gets expanded by Python.
   39   'RULE_INPUT_PATH': '$(RULE_SOURCES)',
   40   'RULE_INPUT_EXT': '$(suffix $<)',
   41   'RULE_INPUT_NAME': '$(notdir $<)',
   42   'CONFIGURATION_NAME': '$(GYP_CONFIGURATION)',
   43 }
   44 
   45 # Make supports multiple toolsets
   46 generator_supports_multiple_toolsets = True
   47 
   48 
   49 # Generator-specific gyp specs.
   50 generator_additional_non_configuration_keys = [
   51     # Boolean to declare that this target does not want its name mangled.
   52     'android_unmangled_name',
   53     # Map of android build system variables to set.
   54     'aosp_build_settings',
   55 ]
   56 generator_additional_path_sections = []
   57 generator_extra_sources_for_rules = []
   58 
   59 
   60 ALL_MODULES_FOOTER = """\
   61 # "gyp_all_modules" is a concatenation of the "gyp_all_modules" targets from
   62 # all the included sub-makefiles. This is just here to clarify.
   63 gyp_all_modules:
   64 """
   65 
   66 header = """\
   67 # This file is generated by gyp; do not edit.
   68 
   69 """
   70 
   71 # Map gyp target types to Android module classes.
   72 MODULE_CLASSES = {
   73     'static_library': 'STATIC_LIBRARIES',
   74     'shared_library': 'SHARED_LIBRARIES',
   75     'executable': 'EXECUTABLES',
   76 }
   77 
   78 
   79 def IsCPPExtension(ext):
   80   return make.COMPILABLE_EXTENSIONS.get(ext) == 'cxx'
   81 
   82 
   83 def Sourceify(path):
   84   """Convert a path to its source directory form. The Android backend does not
   85      support options.generator_output, so this function is a noop."""
   86   return path
   87 
   88 
   89 # Map from qualified target to path to output.
   90 # For Android, the target of these maps is a tuple ('static', 'modulename'),
   91 # ('dynamic', 'modulename'), or ('path', 'some/path') instead of a string,
   92 # since we link by module.
   93 target_outputs = {}
   94 # Map from qualified target to any linkable output.  A subset
   95 # of target_outputs.  E.g. when mybinary depends on liba, we want to
   96 # include liba in the linker line; when otherbinary depends on
   97 # mybinary, we just want to build mybinary first.
   98 target_link_deps = {}
   99 
  100 
  101 class AndroidMkWriter(object):
  102   """AndroidMkWriter packages up the writing of one target-specific Android.mk.
  103 
  104   Its only real entry point is Write(), and is mostly used for namespacing.
  105   """
  106 
  107   def __init__(self, android_top_dir):
  108     self.android_top_dir = android_top_dir
  109 
  110   def Write(self, qualified_target, relative_target, base_path, output_filename,
  111             spec, configs, part_of_all, write_alias_target, sdk_version):
  112     """The main entry point: writes a .mk file for a single target.
  113 
  114     Arguments:
  115       qualified_target: target we're generating
  116       relative_target: qualified target name relative to the root
  117       base_path: path relative to source root we're building in, used to resolve
  118                  target-relative paths
  119       output_filename: output .mk file name to write
  120       spec, configs: gyp info
  121       part_of_all: flag indicating this target is part of 'all'
  122       write_alias_target: flag indicating whether to create short aliases for
  123                           this target
  124       sdk_version: what to emit for LOCAL_SDK_VERSION in output
  125     """
  126     gyp.common.EnsureDirExists(output_filename)
  127 
  128     self.fp = open(output_filename, 'w')
  129 
  130     self.fp.write(header)
  131 
  132     self.qualified_target = qualified_target
  133     self.relative_target = relative_target
  134     self.path = base_path
  135     self.target = spec['target_name']
  136     self.type = spec['type']
  137     self.toolset = spec['toolset']
  138 
  139     deps, link_deps = self.ComputeDeps(spec)
  140 
  141     # Some of the generation below can add extra output, sources, or
  142     # link dependencies.  All of the out params of the functions that
  143     # follow use names like extra_foo.
  144     extra_outputs = []
  145     extra_sources = []
  146 
  147     self.android_class = MODULE_CLASSES.get(self.type, 'GYP')
  148     self.android_module = self.ComputeAndroidModule(spec)
  149     (self.android_stem, self.android_suffix) = self.ComputeOutputParts(spec)
  150     self.output = self.output_binary = self.ComputeOutput(spec)
  151 
  152     # Standard header.
  153     self.WriteLn('include $(CLEAR_VARS)\n')
  154 
  155     # Module class and name.
  156     self.WriteLn('LOCAL_MODULE_CLASS := ' + self.android_class)
  157     self.WriteLn('LOCAL_MODULE := ' + self.android_module)
  158     # Only emit LOCAL_MODULE_STEM if it's different to LOCAL_MODULE.
  159     # The library module classes fail if the stem is set. ComputeOutputParts
  160     # makes sure that stem == modulename in these cases.
  161     if self.android_stem != self.android_module:
  162       self.WriteLn('LOCAL_MODULE_STEM := ' + self.android_stem)
  163     self.WriteLn('LOCAL_MODULE_SUFFIX := ' + self.android_suffix)
  164     if self.toolset == 'host':
  165       self.WriteLn('LOCAL_IS_HOST_MODULE := true')
  166       self.WriteLn('LOCAL_MULTILIB := $(GYP_HOST_MULTILIB)')
  167     elif sdk_version > 0:
  168       self.WriteLn('LOCAL_MODULE_TARGET_ARCH := '
  169                    '$(TARGET_$(GYP_VAR_PREFIX)ARCH)')
  170       self.WriteLn('LOCAL_SDK_VERSION := %s' % sdk_version)
  171 
  172     # Grab output directories; needed for Actions and Rules.
  173     if self.toolset == 'host':
  174       self.WriteLn('gyp_intermediate_dir := '
  175                    '$(call local-intermediates-dir,,$(GYP_HOST_VAR_PREFIX))')
  176     else:
  177       self.WriteLn('gyp_intermediate_dir := '
  178                    '$(call local-intermediates-dir,,$(GYP_VAR_PREFIX))')
  179     self.WriteLn('gyp_shared_intermediate_dir := '
  180                  '$(call intermediates-dir-for,GYP,shared,,,$(GYP_VAR_PREFIX))')
  181     self.WriteLn()
  182 
  183     # List files this target depends on so that actions/rules/copies/sources
  184     # can depend on the list.
  185     # TODO: doesn't pull in things through transitive link deps; needed?
  186     target_dependencies = [x[1] for x in deps if x[0] == 'path']
  187     self.WriteLn('# Make sure our deps are built first.')
  188     self.WriteList(target_dependencies, 'GYP_TARGET_DEPENDENCIES',
  189                    local_pathify=True)
  190 
  191     # Actions must come first, since they can generate more OBJs for use below.
  192     if 'actions' in spec:
  193       self.WriteActions(spec['actions'], extra_sources, extra_outputs)
  194 
  195     # Rules must be early like actions.
  196     if 'rules' in spec:
  197       self.WriteRules(spec['rules'], extra_sources, extra_outputs)
  198 
  199     if 'copies' in spec:
  200       self.WriteCopies(spec['copies'], extra_outputs)
  201 
  202     # GYP generated outputs.
  203     self.WriteList(extra_outputs, 'GYP_GENERATED_OUTPUTS', local_pathify=True)
  204 
  205     # Set LOCAL_ADDITIONAL_DEPENDENCIES so that Android's build rules depend
  206     # on both our dependency targets and our generated files.
  207     self.WriteLn('# Make sure our deps and generated files are built first.')
  208     self.WriteLn('LOCAL_ADDITIONAL_DEPENDENCIES := $(GYP_TARGET_DEPENDENCIES) '
  209                  '$(GYP_GENERATED_OUTPUTS)')
  210     self.WriteLn()
  211 
  212     # Sources.
  213     if spec.get('sources', []) or extra_sources:
  214       self.WriteSources(spec, configs, extra_sources)
  215 
  216     self.WriteTarget(spec, configs, deps, link_deps, part_of_all,
  217                      write_alias_target)
  218 
  219     # Update global list of target outputs, used in dependency tracking.
  220     target_outputs[qualified_target] = ('path', self.output_binary)
  221 
  222     # Update global list of link dependencies.
  223     if self.type == 'static_library':
  224       target_link_deps[qualified_target] = ('static', self.android_module)
  225     elif self.type == 'shared_library':
  226       target_link_deps[qualified_target] = ('shared', self.android_module)
  227 
  228     self.fp.close()
  229     return self.android_module
  230 
  231 
  232   def WriteActions(self, actions, extra_sources, extra_outputs):
  233     """Write Makefile code for any 'actions' from the gyp input.
  234 
  235     extra_sources: a list that will be filled in with newly generated source
  236                    files, if any
  237     extra_outputs: a list that will be filled in with any outputs of these
  238                    actions (used to make other pieces dependent on these
  239                    actions)
  240     """
  241     for action in actions:
  242       name = make.StringToMakefileVariable('%s_%s' % (self.relative_target,
  243                                                       action['action_name']))
  244       self.WriteLn('### Rules for action "%s":' % action['action_name'])
  245       inputs = action['inputs']
  246       outputs = action['outputs']
  247 
  248       # Build up a list of outputs.
  249       # Collect the output dirs we'll need.
  250       dirs = set()
  251       for out in outputs:
  252         if not out.startswith('$'):
  253           print ('WARNING: Action for target "%s" writes output to local path '
  254                  '"%s".' % (self.target, out))
  255         dir = os.path.split(out)[0]
  256         if dir:
  257           dirs.add(dir)
  258       if int(action.get('process_outputs_as_sources', False)):
  259         extra_sources += outputs
  260 
  261       # Prepare the actual command.
  262       command = gyp.common.EncodePOSIXShellList(action['action'])
  263       if 'message' in action:
  264         quiet_cmd = 'Gyp action: %s ($@)' % action['message']
  265       else:
  266         quiet_cmd = 'Gyp action: %s ($@)' % name
  267       if len(dirs) > 0:
  268         command = 'mkdir -p %s' % ' '.join(dirs) + '; ' + command
  269 
  270       cd_action = 'cd $(gyp_local_path)/%s; ' % self.path
  271       command = cd_action + command
  272 
  273       # The makefile rules are all relative to the top dir, but the gyp actions
  274       # are defined relative to their containing dir.  This replaces the gyp_*
  275       # variables for the action rule with an absolute version so that the
  276       # output goes in the right place.
  277       # Only write the gyp_* rules for the "primary" output (:1);
  278       # it's superfluous for the "extra outputs", and this avoids accidentally
  279       # writing duplicate dummy rules for those outputs.
  280       main_output = make.QuoteSpaces(self.LocalPathify(outputs[0]))
  281       self.WriteLn('%s: gyp_local_path := $(LOCAL_PATH)' % main_output)
  282       self.WriteLn('%s: gyp_var_prefix := $(GYP_VAR_PREFIX)' % main_output)
  283       self.WriteLn('%s: gyp_intermediate_dir := '
  284                    '$(abspath $(gyp_intermediate_dir))' % main_output)
  285       self.WriteLn('%s: gyp_shared_intermediate_dir := '
  286                    '$(abspath $(gyp_shared_intermediate_dir))' % main_output)
  287 
  288       # Android's envsetup.sh adds a number of directories to the path including
  289       # the built host binary directory. This causes actions/rules invoked by
  290       # gyp to sometimes use these instead of system versions, e.g. bison.
  291       # The built host binaries may not be suitable, and can cause errors.
  292       # So, we remove them from the PATH using the ANDROID_BUILD_PATHS variable
  293       # set by envsetup.
  294       self.WriteLn('%s: export PATH := $(subst $(ANDROID_BUILD_PATHS),,$(PATH))'
  295                    % main_output)
  296 
  297       # Don't allow spaces in input/output filenames, but make an exception for
  298       # filenames which start with '$(' since it's okay for there to be spaces
  299       # inside of make function/macro invocations.
  300       for input in inputs:
  301         if not input.startswith('$(') and ' ' in input:
  302           raise gyp.common.GypError(
  303               'Action input filename "%s" in target %s contains a space' %
  304               (input, self.target))
  305       for output in outputs:
  306         if not output.startswith('$(') and ' ' in output:
  307           raise gyp.common.GypError(
  308               'Action output filename "%s" in target %s contains a space' %
  309               (output, self.target))
  310 
  311       self.WriteLn('%s: %s $(GYP_TARGET_DEPENDENCIES)' %
  312                    (main_output, ' '.join(map(self.LocalPathify, inputs))))
  313       self.WriteLn('\t@echo "%s"' % quiet_cmd)
  314       self.WriteLn('\t$(hide)%s\n' % command)
  315       for output in outputs[1:]:
  316         # Make each output depend on the main output, with an empty command
  317         # to force make to notice that the mtime has changed.
  318         self.WriteLn('%s: %s ;' % (self.LocalPathify(output), main_output))
  319 
  320       extra_outputs += outputs
  321       self.WriteLn()
  322 
  323     self.WriteLn()
  324 
  325 
  326   def WriteRules(self, rules, extra_sources, extra_outputs):
  327     """Write Makefile code for any 'rules' from the gyp input.
  328 
  329     extra_sources: a list that will be filled in with newly generated source
  330                    files, if any
  331     extra_outputs: a list that will be filled in with any outputs of these
  332                    rules (used to make other pieces dependent on these rules)
  333     """
  334     if len(rules) == 0:
  335       return
  336 
  337     for rule in rules:
  338       if len(rule.get('rule_sources', [])) == 0:
  339         continue
  340       name = make.StringToMakefileVariable('%s_%s' % (self.relative_target,
  341                                                       rule['rule_name']))
  342       self.WriteLn('\n### Generated for rule "%s":' % name)
  343       self.WriteLn('# "%s":' % rule)
  344 
  345       inputs = rule.get('inputs')
  346       for rule_source in rule.get('rule_sources', []):
  347         (rule_source_dirname, rule_source_basename) = os.path.split(rule_source)
  348         (rule_source_root, rule_source_ext) = \
  349             os.path.splitext(rule_source_basename)
  350 
  351         outputs = [self.ExpandInputRoot(out, rule_source_root,
  352                                         rule_source_dirname)
  353                    for out in rule['outputs']]
  354 
  355         dirs = set()
  356         for out in outputs:
  357           if not out.startswith('$'):
  358             print ('WARNING: Rule for target %s writes output to local path %s'
  359                    % (self.target, out))
  360           dir = os.path.dirname(out)
  361           if dir:
  362             dirs.add(dir)
  363         extra_outputs += outputs
  364         if int(rule.get('process_outputs_as_sources', False)):
  365           extra_sources.extend(outputs)
  366 
  367         components = []
  368         for component in rule['action']:
  369           component = self.ExpandInputRoot(component, rule_source_root,
  370                                            rule_source_dirname)
  371           if '$(RULE_SOURCES)' in component:
  372             component = component.replace('$(RULE_SOURCES)',
  373                                           rule_source)
  374           components.append(component)
  375 
  376         command = gyp.common.EncodePOSIXShellList(components)
  377         cd_action = 'cd $(gyp_local_path)/%s; ' % self.path
  378         command = cd_action + command
  379         if dirs:
  380           command = 'mkdir -p %s' % ' '.join(dirs) + '; ' + command
  381 
  382         # We set up a rule to build the first output, and then set up
  383         # a rule for each additional output to depend on the first.
  384         outputs = map(self.LocalPathify, outputs)
  385         main_output = outputs[0]
  386         self.WriteLn('%s: gyp_local_path := $(LOCAL_PATH)' % main_output)
  387         self.WriteLn('%s: gyp_var_prefix := $(GYP_VAR_PREFIX)' % main_output)
  388         self.WriteLn('%s: gyp_intermediate_dir := '
  389                      '$(abspath $(gyp_intermediate_dir))' % main_output)
  390         self.WriteLn('%s: gyp_shared_intermediate_dir := '
  391                      '$(abspath $(gyp_shared_intermediate_dir))' % main_output)
  392 
  393         # See explanation in WriteActions.
  394         self.WriteLn('%s: export PATH := '
  395                      '$(subst $(ANDROID_BUILD_PATHS),,$(PATH))' % main_output)
  396 
  397         main_output_deps = self.LocalPathify(rule_source)
  398         if inputs:
  399           main_output_deps += ' '
  400           main_output_deps += ' '.join([self.LocalPathify(f) for f in inputs])
  401 
  402         self.WriteLn('%s: %s $(GYP_TARGET_DEPENDENCIES)' %
  403                      (main_output, main_output_deps))
  404         self.WriteLn('\t%s\n' % command)
  405         for output in outputs[1:]:
  406           # Make each output depend on the main output, with an empty command
  407           # to force make to notice that the mtime has changed.
  408           self.WriteLn('%s: %s ;' % (output, main_output))
  409         self.WriteLn()
  410 
  411     self.WriteLn()
  412 
  413 
  414   def WriteCopies(self, copies, extra_outputs):
  415     """Write Makefile code for any 'copies' from the gyp input.
  416 
  417     extra_outputs: a list that will be filled in with any outputs of this action
  418                    (used to make other pieces dependent on this action)
  419     """
  420     self.WriteLn('### Generated for copy rule.')
  421 
  422     variable = make.StringToMakefileVariable(self.relative_target + '_copies')
  423     outputs = []
  424     for copy in copies:
  425       for path in copy['files']:
  426         # The Android build system does not allow generation of files into the
  427         # source tree. The destination should start with a variable, which will
  428         # typically be $(gyp_intermediate_dir) or
  429         # $(gyp_shared_intermediate_dir). Note that we can't use an assertion
  430         # because some of the gyp tests depend on this.
  431         if not copy['destination'].startswith('$'):
  432           print ('WARNING: Copy rule for target %s writes output to '
  433                  'local path %s' % (self.target, copy['destination']))
  434 
  435         # LocalPathify() calls normpath, stripping trailing slashes.
  436         path = Sourceify(self.LocalPathify(path))
  437         filename = os.path.split(path)[1]
  438         output = Sourceify(self.LocalPathify(os.path.join(copy['destination'],
  439                                                           filename)))
  440 
  441         self.WriteLn('%s: %s $(GYP_TARGET_DEPENDENCIES) | $(ACP)' %
  442                      (output, path))
  443         self.WriteLn('\t@echo Copying: $@')
  444         self.WriteLn('\t$(hide) mkdir -p $(dir $@)')
  445         self.WriteLn('\t$(hide) $(ACP) -rpf $< $@')
  446         self.WriteLn()
  447         outputs.append(output)
  448     self.WriteLn('%s = %s' % (variable,
  449                               ' '.join(map(make.QuoteSpaces, outputs))))
  450     extra_outputs.append('$(%s)' % variable)
  451     self.WriteLn()
  452 
  453 
  454   def WriteSourceFlags(self, spec, configs):
  455     """Write out the flags and include paths used to compile source files for
  456     the current target.
  457 
  458     Args:
  459       spec, configs: input from gyp.
  460     """
  461     for configname, config in sorted(configs.iteritems()):
  462       extracted_includes = []
  463 
  464       self.WriteLn('\n# Flags passed to both C and C++ files.')
  465       cflags, includes_from_cflags = self.ExtractIncludesFromCFlags(
  466           config.get('cflags', []) + config.get('cflags_c', []))
  467       extracted_includes.extend(includes_from_cflags)
  468       self.WriteList(cflags, 'MY_CFLAGS_%s' % configname)
  469 
  470       self.WriteList(config.get('defines'), 'MY_DEFS_%s' % configname,
  471                      prefix='-D', quoter=make.EscapeCppDefine)
  472 
  473       self.WriteLn('\n# Include paths placed before CFLAGS/CPPFLAGS')
  474       includes = list(config.get('include_dirs', []))
  475       includes.extend(extracted_includes)
  476       includes = map(Sourceify, map(self.LocalPathify, includes))
  477       includes = self.NormalizeIncludePaths(includes)
  478       self.WriteList(includes, 'LOCAL_C_INCLUDES_%s' % configname)
  479 
  480       self.WriteLn('\n# Flags passed to only C++ (and not C) files.')
  481       self.WriteList(config.get('cflags_cc'), 'LOCAL_CPPFLAGS_%s' % configname)
  482 
  483     self.WriteLn('\nLOCAL_CFLAGS := $(MY_CFLAGS_$(GYP_CONFIGURATION)) '
  484                  '$(MY_DEFS_$(GYP_CONFIGURATION))')
  485     # Undefine ANDROID for host modules
  486     # TODO: the source code should not use macro ANDROID to tell if it's host
  487     # or target module.
  488     if self.toolset == 'host':
  489       self.WriteLn('# Undefine ANDROID for host modules')
  490       self.WriteLn('LOCAL_CFLAGS += -UANDROID')
  491     self.WriteLn('LOCAL_C_INCLUDES := $(GYP_COPIED_SOURCE_ORIGIN_DIRS) '
  492                                      '$(LOCAL_C_INCLUDES_$(GYP_CONFIGURATION))')
  493     self.WriteLn('LOCAL_CPPFLAGS := $(LOCAL_CPPFLAGS_$(GYP_CONFIGURATION))')
  494     # Android uses separate flags for assembly file invocations, but gyp expects
  495     # the same CFLAGS to be applied:
  496     self.WriteLn('LOCAL_ASFLAGS := $(LOCAL_CFLAGS)')
  497 
  498 
  499   def WriteSources(self, spec, configs, extra_sources):
  500     """Write Makefile code for any 'sources' from the gyp input.
  501     These are source files necessary to build the current target.
  502     We need to handle shared_intermediate directory source files as
  503     a special case by copying them to the intermediate directory and
  504     treating them as a genereated sources. Otherwise the Android build
  505     rules won't pick them up.
  506 
  507     Args:
  508       spec, configs: input from gyp.
  509       extra_sources: Sources generated from Actions or Rules.
  510     """
  511     sources = filter(make.Compilable, spec.get('sources', []))
  512     generated_not_sources = [x for x in extra_sources if not make.Compilable(x)]
  513     extra_sources = filter(make.Compilable, extra_sources)
  514 
  515     # Determine and output the C++ extension used by these sources.
  516     # We simply find the first C++ file and use that extension.
  517     all_sources = sources + extra_sources
  518     local_cpp_extension = '.cpp'
  519     for source in all_sources:
  520       (root, ext) = os.path.splitext(source)
  521       if IsCPPExtension(ext):
  522         local_cpp_extension = ext
  523         break
  524     if local_cpp_extension != '.cpp':
  525       self.WriteLn('LOCAL_CPP_EXTENSION := %s' % local_cpp_extension)
  526 
  527     # We need to move any non-generated sources that are coming from the
  528     # shared intermediate directory out of LOCAL_SRC_FILES and put them
  529     # into LOCAL_GENERATED_SOURCES. We also need to move over any C++ files
  530     # that don't match our local_cpp_extension, since Android will only
  531     # generate Makefile rules for a single LOCAL_CPP_EXTENSION.
  532     local_files = []
  533     for source in sources:
  534       (root, ext) = os.path.splitext(source)
  535       if '$(gyp_shared_intermediate_dir)' in source:
  536         extra_sources.append(source)
  537       elif '$(gyp_intermediate_dir)' in source:
  538         extra_sources.append(source)
  539       elif IsCPPExtension(ext) and ext != local_cpp_extension:
  540         extra_sources.append(source)
  541       else:
  542         local_files.append(os.path.normpath(os.path.join(self.path, source)))
  543 
  544     # For any generated source, if it is coming from the shared intermediate
  545     # directory then we add a Make rule to copy them to the local intermediate
  546     # directory first. This is because the Android LOCAL_GENERATED_SOURCES
  547     # must be in the local module intermediate directory for the compile rules
  548     # to work properly. If the file has the wrong C++ extension, then we add
  549     # a rule to copy that to intermediates and use the new version.
  550     final_generated_sources = []
  551     # If a source file gets copied, we still need to add the orginal source
  552     # directory as header search path, for GCC searches headers in the
  553     # directory that contains the source file by default.
  554     origin_src_dirs = []
  555     for source in extra_sources:
  556       local_file = source
  557       if not '$(gyp_intermediate_dir)/' in local_file:
  558         basename = os.path.basename(local_file)
  559         local_file = '$(gyp_intermediate_dir)/' + basename
  560       (root, ext) = os.path.splitext(local_file)
  561       if IsCPPExtension(ext) and ext != local_cpp_extension:
  562         local_file = root + local_cpp_extension
  563       if local_file != source:
  564         self.WriteLn('%s: %s' % (local_file, self.LocalPathify(source)))
  565         self.WriteLn('\tmkdir -p $(@D); cp $< $@')
  566         origin_src_dirs.append(os.path.dirname(source))
  567       final_generated_sources.append(local_file)
  568 
  569     # We add back in all of the non-compilable stuff to make sure that the
  570     # make rules have dependencies on them.
  571     final_generated_sources.extend(generated_not_sources)
  572     self.WriteList(final_generated_sources, 'LOCAL_GENERATED_SOURCES')
  573 
  574     origin_src_dirs = gyp.common.uniquer(origin_src_dirs)
  575     origin_src_dirs = map(Sourceify, map(self.LocalPathify, origin_src_dirs))
  576     self.WriteList(origin_src_dirs, 'GYP_COPIED_SOURCE_ORIGIN_DIRS')
  577 
  578     self.WriteList(local_files, 'LOCAL_SRC_FILES')
  579 
  580     # Write out the flags used to compile the source; this must be done last
  581     # so that GYP_COPIED_SOURCE_ORIGIN_DIRS can be used as an include path.
  582     self.WriteSourceFlags(spec, configs)
  583 
  584 
  585   def ComputeAndroidModule(self, spec):
  586     """Return the Android module name used for a gyp spec.
  587 
  588     We use the complete qualified target name to avoid collisions between
  589     duplicate targets in different directories. We also add a suffix to
  590     distinguish gyp-generated module names.
  591     """
  592 
  593     if int(spec.get('android_unmangled_name', 0)):
  594       assert self.type != 'shared_library' or self.target.startswith('lib')
  595       return self.target
  596 
  597     if self.type == 'shared_library':
  598       # For reasons of convention, the Android build system requires that all
  599       # shared library modules are named 'libfoo' when generating -l flags.
  600       prefix = 'lib_'
  601     else:
  602       prefix = ''
  603 
  604     if spec['toolset'] == 'host':
  605       suffix = '_$(TARGET_$(GYP_VAR_PREFIX)ARCH)_host_gyp'
  606     else:
  607       suffix = '_gyp'
  608 
  609     if self.path:
  610       middle = make.StringToMakefileVariable('%s_%s' % (self.path, self.target))
  611     else:
  612       middle = make.StringToMakefileVariable(self.target)
  613 
  614     return ''.join([prefix, middle, suffix])
  615 
  616 
  617   def ComputeOutputParts(self, spec):
  618     """Return the 'output basename' of a gyp spec, split into filename + ext.
  619 
  620     Android libraries must be named the same thing as their module name,
  621     otherwise the linker can't find them, so product_name and so on must be
  622     ignored if we are building a library, and the "lib" prepending is
  623     not done for Android.
  624     """
  625     assert self.type != 'loadable_module' # TODO: not supported?
  626 
  627     target = spec['target_name']
  628     target_prefix = ''
  629     target_ext = ''
  630     if self.type == 'static_library':
  631       target = self.ComputeAndroidModule(spec)
  632       target_ext = '.a'
  633     elif self.type == 'shared_library':
  634       target = self.ComputeAndroidModule(spec)
  635       target_ext = '.so'
  636     elif self.type == 'none':
  637       target_ext = '.stamp'
  638     elif self.type != 'executable':
  639       print ("ERROR: What output file should be generated?",
  640              "type", self.type, "target", target)
  641 
  642     if self.type != 'static_library' and self.type != 'shared_library':
  643       target_prefix = spec.get('product_prefix', target_prefix)
  644       target = spec.get('product_name', target)
  645       product_ext = spec.get('product_extension')
  646       if product_ext:
  647         target_ext = '.' + product_ext
  648 
  649     target_stem = target_prefix + target
  650     return (target_stem, target_ext)
  651 
  652 
  653   def ComputeOutputBasename(self, spec):
  654     """Return the 'output basename' of a gyp spec.
  655 
  656     E.g., the loadable module 'foobar' in directory 'baz' will produce
  657       'libfoobar.so'
  658     """
  659     return ''.join(self.ComputeOutputParts(spec))
  660 
  661 
  662   def ComputeOutput(self, spec):
  663     """Return the 'output' (full output path) of a gyp spec.
  664 
  665     E.g., the loadable module 'foobar' in directory 'baz' will produce
  666       '$(obj)/baz/libfoobar.so'
  667     """
  668     if self.type == 'executable':
  669       # We install host executables into shared_intermediate_dir so they can be
  670       # run by gyp rules that refer to PRODUCT_DIR.
  671       path = '$(gyp_shared_intermediate_dir)'
  672     elif self.type == 'shared_library':
  673       if self.toolset == 'host':
  674         path = '$($(GYP_HOST_VAR_PREFIX)HOST_OUT_INTERMEDIATE_LIBRARIES)'
  675       else:
  676         path = '$($(GYP_VAR_PREFIX)TARGET_OUT_INTERMEDIATE_LIBRARIES)'
  677     else:
  678       # Other targets just get built into their intermediate dir.
  679       if self.toolset == 'host':
  680         path = ('$(call intermediates-dir-for,%s,%s,true,,'
  681                 '$(GYP_HOST_VAR_PREFIX))' % (self.android_class,
  682                                              self.android_module))
  683       else:
  684         path = ('$(call intermediates-dir-for,%s,%s,,,$(GYP_VAR_PREFIX))'
  685                 % (self.android_class, self.android_module))
  686 
  687     assert spec.get('product_dir') is None # TODO: not supported?
  688     return os.path.join(path, self.ComputeOutputBasename(spec))
  689 
  690   def NormalizeIncludePaths(self, include_paths):
  691     """ Normalize include_paths.
  692     Convert absolute paths to relative to the Android top directory.
  693 
  694     Args:
  695       include_paths: A list of unprocessed include paths.
  696     Returns:
  697       A list of normalized include paths.
  698     """
  699     normalized = []
  700     for path in include_paths:
  701       if path[0] == '/':
  702         path = gyp.common.RelativePath(path, self.android_top_dir)
  703       normalized.append(path)
  704     return normalized
  705 
  706   def ExtractIncludesFromCFlags(self, cflags):
  707     """Extract includes "-I..." out from cflags
  708 
  709     Args:
  710       cflags: A list of compiler flags, which may be mixed with "-I.."
  711     Returns:
  712       A tuple of lists: (clean_clfags, include_paths). "-I.." is trimmed.
  713     """
  714     clean_cflags = []
  715     include_paths = []
  716     for flag in cflags:
  717       if flag.startswith('-I'):
  718         include_paths.append(flag[2:])
  719       else:
  720         clean_cflags.append(flag)
  721 
  722     return (clean_cflags, include_paths)
  723 
  724   def FilterLibraries(self, libraries):
  725     """Filter the 'libraries' key to separate things that shouldn't be ldflags.
  726 
  727     Library entries that look like filenames should be converted to android
  728     module names instead of being passed to the linker as flags.
  729 
  730     Args:
  731       libraries: the value of spec.get('libraries')
  732     Returns:
  733       A tuple (static_lib_modules, dynamic_lib_modules, ldflags)
  734     """
  735     static_lib_modules = []
  736     dynamic_lib_modules = []
  737     ldflags = []
  738     for libs in libraries:
  739       # Libs can have multiple words.
  740       for lib in libs.split():
  741         # Filter the system libraries, which are added by default by the Android
  742         # build system.
  743         if (lib == '-lc' or lib == '-lstdc++' or lib == '-lm' or
  744             lib.endswith('libgcc.a')):
  745           continue
  746         match = re.search(r'([^/]+)\.a$', lib)
  747         if match:
  748           static_lib_modules.append(match.group(1))
  749           continue
  750         match = re.search(r'([^/]+)\.so$', lib)
  751         if match:
  752           dynamic_lib_modules.append(match.group(1))
  753           continue
  754         if lib.startswith('-l'):
  755           ldflags.append(lib)
  756     return (static_lib_modules, dynamic_lib_modules, ldflags)
  757 
  758 
  759   def ComputeDeps(self, spec):
  760     """Compute the dependencies of a gyp spec.
  761 
  762     Returns a tuple (deps, link_deps), where each is a list of
  763     filenames that will need to be put in front of make for either
  764     building (deps) or linking (link_deps).
  765     """
  766     deps = []
  767     link_deps = []
  768     if 'dependencies' in spec:
  769       deps.extend([target_outputs[dep] for dep in spec['dependencies']
  770                    if target_outputs[dep]])
  771       for dep in spec['dependencies']:
  772         if dep in target_link_deps:
  773           link_deps.append(target_link_deps[dep])
  774       deps.extend(link_deps)
  775     return (gyp.common.uniquer(deps), gyp.common.uniquer(link_deps))
  776 
  777 
  778   def WriteTargetFlags(self, spec, configs, link_deps):
  779     """Write Makefile code to specify the link flags and library dependencies.
  780 
  781     spec, configs: input from gyp.
  782     link_deps: link dependency list; see ComputeDeps()
  783     """
  784     # Libraries (i.e. -lfoo)
  785     # These must be included even for static libraries as some of them provide
  786     # implicit include paths through the build system.
  787     libraries = gyp.common.uniquer(spec.get('libraries', []))
  788     static_libs, dynamic_libs, ldflags_libs = self.FilterLibraries(libraries)
  789 
  790     if self.type != 'static_library':
  791       for configname, config in sorted(configs.iteritems()):
  792         ldflags = list(config.get('ldflags', []))
  793         self.WriteLn('')
  794         self.WriteList(ldflags, 'LOCAL_LDFLAGS_%s' % configname)
  795       self.WriteList(ldflags_libs, 'LOCAL_GYP_LIBS')
  796       self.WriteLn('LOCAL_LDFLAGS := $(LOCAL_LDFLAGS_$(GYP_CONFIGURATION)) '
  797                    '$(LOCAL_GYP_LIBS)')
  798 
  799     # Link dependencies (i.e. other gyp targets this target depends on)
  800     # These need not be included for static libraries as within the gyp build
  801     # we do not use the implicit include path mechanism.
  802     if self.type != 'static_library':
  803       static_link_deps = [x[1] for x in link_deps if x[0] == 'static']
  804       shared_link_deps = [x[1] for x in link_deps if x[0] == 'shared']
  805     else:
  806       static_link_deps = []
  807       shared_link_deps = []
  808 
  809     # Only write the lists if they are non-empty.
  810     if static_libs or static_link_deps:
  811       self.WriteLn('')
  812       self.WriteList(static_libs + static_link_deps,
  813                      'LOCAL_STATIC_LIBRARIES')
  814       self.WriteLn('# Enable grouping to fix circular references')
  815       self.WriteLn('LOCAL_GROUP_STATIC_LIBRARIES := true')
  816     if dynamic_libs or shared_link_deps:
  817       self.WriteLn('')
  818       self.WriteList(dynamic_libs + shared_link_deps,
  819                      'LOCAL_SHARED_LIBRARIES')
  820 
  821 
  822   def WriteTarget(self, spec, configs, deps, link_deps, part_of_all,
  823                   write_alias_target):
  824     """Write Makefile code to produce the final target of the gyp spec.
  825 
  826     spec, configs: input from gyp.
  827     deps, link_deps: dependency lists; see ComputeDeps()
  828     part_of_all: flag indicating this target is part of 'all'
  829     write_alias_target: flag indicating whether to create short aliases for this
  830                         target
  831     """
  832     self.WriteLn('### Rules for final target.')
  833 
  834     if self.type != 'none':
  835       self.WriteTargetFlags(spec, configs, link_deps)
  836 
  837     settings = spec.get('aosp_build_settings', {})
  838     if settings:
  839       self.WriteLn('### Set directly by aosp_build_settings.')
  840       for k, v in settings.iteritems():
  841         if isinstance(v, list):
  842           self.WriteList(v, k)
  843         else:
  844           self.WriteLn('%s := %s' % (k, make.QuoteIfNecessary(v)))
  845       self.WriteLn('')
  846 
  847     # Add to the set of targets which represent the gyp 'all' target. We use the
  848     # name 'gyp_all_modules' as the Android build system doesn't allow the use
  849     # of the Make target 'all' and because 'all_modules' is the equivalent of
  850     # the Make target 'all' on Android.
  851     if part_of_all and write_alias_target:
  852       self.WriteLn('# Add target alias to "gyp_all_modules" target.')
  853       self.WriteLn('.PHONY: gyp_all_modules')
  854       self.WriteLn('gyp_all_modules: %s' % self.android_module)
  855       self.WriteLn('')
  856 
  857     # Add an alias from the gyp target name to the Android module name. This
  858     # simplifies manual builds of the target, and is required by the test
  859     # framework.
  860     if self.target != self.android_module and write_alias_target:
  861       self.WriteLn('# Alias gyp target name.')
  862       self.WriteLn('.PHONY: %s' % self.target)
  863       self.WriteLn('%s: %s' % (self.target, self.android_module))
  864       self.WriteLn('')
  865 
  866     # Add the command to trigger build of the target type depending
  867     # on the toolset. Ex: BUILD_STATIC_LIBRARY vs. BUILD_HOST_STATIC_LIBRARY
  868     # NOTE: This has to come last!
  869     modifier = ''
  870     if self.toolset == 'host':
  871       modifier = 'HOST_'
  872     if self.type == 'static_library':
  873       self.WriteLn('include $(BUILD_%sSTATIC_LIBRARY)' % modifier)
  874     elif self.type == 'shared_library':
  875       self.WriteLn('LOCAL_PRELINK_MODULE := false')
  876       self.WriteLn('include $(BUILD_%sSHARED_LIBRARY)' % modifier)
  877     elif self.type == 'executable':
  878       self.WriteLn('LOCAL_CXX_STL := libc++_static')
  879       # Executables are for build and test purposes only, so they're installed
  880       # to a directory that doesn't get included in the system image.
  881       self.WriteLn('LOCAL_MODULE_PATH := $(gyp_shared_intermediate_dir)')
  882       self.WriteLn('include $(BUILD_%sEXECUTABLE)' % modifier)
  883     else:
  884       self.WriteLn('LOCAL_MODULE_PATH := $(PRODUCT_OUT)/gyp_stamp')
  885       self.WriteLn('LOCAL_UNINSTALLABLE_MODULE := true')
  886       if self.toolset == 'target':
  887         self.WriteLn('LOCAL_2ND_ARCH_VAR_PREFIX := $(GYP_VAR_PREFIX)')
  888       else:
  889         self.WriteLn('LOCAL_2ND_ARCH_VAR_PREFIX := $(GYP_HOST_VAR_PREFIX)')
  890       self.WriteLn()
  891       self.WriteLn('include $(BUILD_SYSTEM)/base_rules.mk')
  892       self.WriteLn()
  893       self.WriteLn('$(LOCAL_BUILT_MODULE): $(LOCAL_ADDITIONAL_DEPENDENCIES)')
  894       self.WriteLn('\t$(hide) echo "Gyp timestamp: $@"')
  895       self.WriteLn('\t$(hide) mkdir -p $(dir $@)')
  896       self.WriteLn('\t$(hide) touch $@')
  897       self.WriteLn()
  898       self.WriteLn('LOCAL_2ND_ARCH_VAR_PREFIX :=')
  899 
  900 
  901   def WriteList(self, value_list, variable=None, prefix='',
  902                 quoter=make.QuoteIfNecessary, local_pathify=False):
  903     """Write a variable definition that is a list of values.
  904 
  905     E.g. WriteList(['a','b'], 'foo', prefix='blah') writes out
  906          foo = blaha blahb
  907     but in a pretty-printed style.
  908     """
  909     values = ''
  910     if value_list:
  911       value_list = [quoter(prefix + l) for l in value_list]
  912       if local_pathify:
  913         value_list = [self.LocalPathify(l) for l in value_list]
  914       values = ' \\\n\t' + ' \\\n\t'.join(value_list)
  915     self.fp.write('%s :=%s\n\n' % (variable, values))
  916 
  917 
  918   def WriteLn(self, text=''):
  919     self.fp.write(text + '\n')
  920 
  921 
  922   def LocalPathify(self, path):
  923     """Convert a subdirectory-relative path into a normalized path which starts
  924     with the make variable $(LOCAL_PATH) (i.e. the top of the project tree).
  925     Absolute paths, or paths that contain variables, are just normalized."""
  926     if '$(' in path or os.path.isabs(path):
  927       # path is not a file in the project tree in this case, but calling
  928       # normpath is still important for trimming trailing slashes.
  929       return os.path.normpath(path)
  930     local_path = os.path.join('$(LOCAL_PATH)', self.path, path)
  931     local_path = os.path.normpath(local_path)
  932     # Check that normalizing the path didn't ../ itself out of $(LOCAL_PATH)
  933     # - i.e. that the resulting path is still inside the project tree. The
  934     # path may legitimately have ended up containing just $(LOCAL_PATH), though,
  935     # so we don't look for a slash.
  936     assert local_path.startswith('$(LOCAL_PATH)'), (
  937            'Path %s attempts to escape from gyp path %s !)' % (path, self.path))
  938     return local_path
  939 
  940 
  941   def ExpandInputRoot(self, template, expansion, dirname):
  942     if '%(INPUT_ROOT)s' not in template and '%(INPUT_DIRNAME)s' not in template:
  943       return template
  944     path = template % {
  945         'INPUT_ROOT': expansion,
  946         'INPUT_DIRNAME': dirname,
  947         }
  948     return os.path.normpath(path)
  949 
  950 
  951 def PerformBuild(data, configurations, params):
  952   # The android backend only supports the default configuration.
  953   options = params['options']
  954   makefile = os.path.abspath(os.path.join(options.toplevel_dir,
  955                                           'GypAndroid.mk'))
  956   env = dict(os.environ)
  957   env['ONE_SHOT_MAKEFILE'] = makefile
  958   arguments = ['make', '-C', os.environ['ANDROID_BUILD_TOP'], 'gyp_all_modules']
  959   print 'Building: %s' % arguments
  960   subprocess.check_call(arguments, env=env)
  961 
  962 
  963 def GenerateOutput(target_list, target_dicts, data, params):
  964   options = params['options']
  965   generator_flags = params.get('generator_flags', {})
  966   builddir_name = generator_flags.get('output_dir', 'out')
  967   limit_to_target_all = generator_flags.get('limit_to_target_all', False)
  968   write_alias_targets = generator_flags.get('write_alias_targets', True)
  969   sdk_version = generator_flags.get('aosp_sdk_version', 0)
  970   android_top_dir = os.environ.get('ANDROID_BUILD_TOP')
  971   assert android_top_dir, '$ANDROID_BUILD_TOP not set; you need to run lunch.'
  972 
  973   def CalculateMakefilePath(build_file, base_name):
  974     """Determine where to write a Makefile for a given gyp file."""
  975     # Paths in gyp files are relative to the .gyp file, but we want
  976     # paths relative to the source root for the master makefile.  Grab
  977     # the path of the .gyp file as the base to relativize against.
  978     # E.g. "foo/bar" when we're constructing targets for "foo/bar/baz.gyp".
  979     base_path = gyp.common.RelativePath(os.path.dirname(build_file),
  980                                         options.depth)
  981     # We write the file in the base_path directory.
  982     output_file = os.path.join(options.depth, base_path, base_name)
  983     assert not options.generator_output, (
  984         'The Android backend does not support options.generator_output.')
  985     base_path = gyp.common.RelativePath(os.path.dirname(build_file),
  986                                         options.toplevel_dir)
  987     return base_path, output_file
  988 
  989   # TODO:  search for the first non-'Default' target.  This can go
  990   # away when we add verification that all targets have the
  991   # necessary configurations.
  992   default_configuration = None
  993   toolsets = set([target_dicts[target]['toolset'] for target in target_list])
  994   for target in target_list:
  995     spec = target_dicts[target]
  996     if spec['default_configuration'] != 'Default':
  997       default_configuration = spec['default_configuration']
  998       break
  999   if not default_configuration:
 1000     default_configuration = 'Default'
 1001 
 1002   srcdir = '.'
 1003   makefile_name = 'GypAndroid' + options.suffix + '.mk'
 1004   makefile_path = os.path.join(options.toplevel_dir, makefile_name)
 1005   assert not options.generator_output, (
 1006       'The Android backend does not support options.generator_output.')
 1007   gyp.common.EnsureDirExists(makefile_path)
 1008   root_makefile = open(makefile_path, 'w')
 1009 
 1010   root_makefile.write(header)
 1011 
 1012   # We set LOCAL_PATH just once, here, to the top of the project tree. This
 1013   # allows all the other paths we use to be relative to the Android.mk file,
 1014   # as the Android build system expects.
 1015   root_makefile.write('\nLOCAL_PATH := $(call my-dir)\n')
 1016 
 1017   # Find the list of targets that derive from the gyp file(s) being built.
 1018   needed_targets = set()
 1019   for build_file in params['build_files']:
 1020     for target in gyp.common.AllTargets(target_list, target_dicts, build_file):
 1021       needed_targets.add(target)
 1022 
 1023   build_files = set()
 1024   include_list = set()
 1025   android_modules = {}
 1026   for qualified_target in target_list:
 1027     build_file, target, toolset = gyp.common.ParseQualifiedTarget(
 1028         qualified_target)
 1029     relative_build_file = gyp.common.RelativePath(build_file,
 1030                                                   options.toplevel_dir)
 1031     build_files.add(relative_build_file)
 1032     included_files = data[build_file]['included_files']
 1033     for included_file in included_files:
 1034       # The included_files entries are relative to the dir of the build file
 1035       # that included them, so we have to undo that and then make them relative
 1036       # to the root dir.
 1037       relative_include_file = gyp.common.RelativePath(
 1038           gyp.common.UnrelativePath(included_file, build_file),
 1039           options.toplevel_dir)
 1040       abs_include_file = os.path.abspath(relative_include_file)
 1041       # If the include file is from the ~/.gyp dir, we should use absolute path
 1042       # so that relocating the src dir doesn't break the path.
 1043       if (params['home_dot_gyp'] and
 1044           abs_include_file.startswith(params['home_dot_gyp'])):
 1045         build_files.add(abs_include_file)
 1046       else:
 1047         build_files.add(relative_include_file)
 1048 
 1049     base_path, output_file = CalculateMakefilePath(build_file,
 1050         target + '.' + toolset + options.suffix + '.mk')
 1051 
 1052     spec = target_dicts[qualified_target]
 1053     configs = spec['configurations']
 1054 
 1055     part_of_all = qualified_target in needed_targets
 1056     if limit_to_target_all and not part_of_all:
 1057       continue
 1058 
 1059     relative_target = gyp.common.QualifiedTarget(relative_build_file, target,
 1060                                                  toolset)
 1061     writer = AndroidMkWriter(android_top_dir)
 1062     android_module = writer.Write(qualified_target, relative_target, base_path,
 1063                                   output_file, spec, configs,
 1064                                   part_of_all=part_of_all,
 1065                                   write_alias_target=write_alias_targets,
 1066                                   sdk_version=sdk_version)
 1067     if android_module in android_modules:
 1068       print ('ERROR: Android module names must be unique. The following '
 1069              'targets both generate Android module name %s.\n  %s\n  %s' %
 1070              (android_module, android_modules[android_module],
 1071               qualified_target))
 1072       return
 1073     android_modules[android_module] = qualified_target
 1074 
 1075     # Our root_makefile lives at the source root.  Compute the relative path
 1076     # from there to the output_file for including.
 1077     mkfile_rel_path = gyp.common.RelativePath(output_file,
 1078                                               os.path.dirname(makefile_path))
 1079     include_list.add(mkfile_rel_path)
 1080 
 1081   root_makefile.write('GYP_CONFIGURATION ?= %s\n' % default_configuration)
 1082   root_makefile.write('GYP_VAR_PREFIX ?=\n')
 1083   root_makefile.write('GYP_HOST_VAR_PREFIX ?=\n')
 1084   root_makefile.write('GYP_HOST_MULTILIB ?= first\n')
 1085 
 1086   # Write out the sorted list of includes.
 1087   root_makefile.write('\n')
 1088   for include_file in sorted(include_list):
 1089     root_makefile.write('include $(LOCAL_PATH)/' + include_file + '\n')
 1090   root_makefile.write('\n')
 1091 
 1092   if write_alias_targets:
 1093     root_makefile.write(ALL_MODULES_FOOTER)
 1094 
 1095   root_makefile.close()