~hjd/ubuntu/wily/gyp/debian-merged

from gyp.common import GypError

generator_filelist_paths = None

  output_dir = params['options'].generator_output or \

               params['options'].toplevel_dir

  builddir_name = generator_flags.get('output_dir', 'out')

  qualified_out_dir = os.path.normpath(os.path.join(

    output_dir, builddir_name, 'gypfiles'))

  global generator_filelist_paths

  generator_filelist_paths = {

    'toplevel': params['options'].toplevel_dir,

    'qualified_out_dir': qualified_out_dir,

  }

LINK_COMMANDS_AIX = """\

quiet_cmd_alink = AR($(TOOLSET)) $@

cmd_alink = rm -f $@ && $(AR.$(TOOLSET)) crs $@ $(filter %.o,$^)

 

quiet_cmd_alink_thin = AR($(TOOLSET)) $@

cmd_alink_thin = rm -f $@ && $(AR.$(TOOLSET)) crs $@ $(filter %.o,$^)

 

quiet_cmd_link = LINK($(TOOLSET)) $@

cmd_link = $(LINK.$(TOOLSET)) $(GYP_LDFLAGS) $(LDFLAGS.$(TOOLSET)) -o $@ $(LD_INPUTS) $(LIBS)

 

quiet_cmd_solink = SOLINK($(TOOLSET)) $@

cmd_solink = $(LINK.$(TOOLSET)) -shared $(GYP_LDFLAGS) $(LDFLAGS.$(TOOLSET)) -o $@ $(LD_INPUTS) $(LIBS)

 

quiet_cmd_solink_module = SOLINK_MODULE($(TOOLSET)) $@

cmd_solink_module = $(LINK.$(TOOLSET)) -shared $(GYP_LDFLAGS) $(LDFLAGS.$(TOOLSET)) -o $@ $(filter-out FORCE_DO_CMD, $^) $(LIBS)

"""

 

 

LINK ?= $(CXX.target)

# TODO: Avoid code duplication with _ValidateSourcesForMSVSProject in msvs.py.

def _ValidateSourcesForOSX(spec, all_sources):

  """Makes sure if duplicate basenames are not specified in the source list.

 

  Arguments:

    spec: The target dictionary containing the properties of the target.

  """

  if spec.get('type', None) != 'static_library':

    return

 

  basenames = {}

  for source in all_sources:

    name, ext = os.path.splitext(source)

    is_compiled_file = ext in [

        '.c', '.cc', '.cpp', '.cxx', '.m', '.mm', '.s', '.S']

    if not is_compiled_file:

      continue

    basename = os.path.basename(name)  # Don't include extension.

    basenames.setdefault(basename, []).append(source)

 

  error = ''

  for basename, files in basenames.iteritems():

    if len(files) > 1:

      error += '  %s: %s\n' % (basename, ' '.join(files))

 

  if error:

    print('static library %s has several files with the same basename:\n' %

          spec['target_name'] + error + 'libtool on OS X will generate' +

          ' warnings for them.')

    raise GypError('Duplicate basenames in sources section, see list above')

 

 

class MakefileWriter(object):

    gyp.common.EnsureDirExists(output_filename)

      if self.flavor == 'mac':

        # libtool on OS X generates warnings for duplicate basenames in the same

        # target.

        _ValidateSourcesForOSX(spec, all_sources)

    gyp.common.EnsureDirExists(output_filename)

        self.WriteMakeRule(outputs, inputs, actions,

                           command="%s_%d" % (name, count))

      _, ext = os.path.splitext(output)

      if ext != '.xcassets':

        # Make does not supports '.xcassets' emulation.

        self.WriteDoCmd([output], [res], 'mac_tool,,,copy-bundle-resource',

                        part_of_all=True)

        bundle_deps.append(output)

          target_postbuild = self.xcode_settings.AddImplicitPostbuilds(

                       command = command,

                    order_only=False, force=False, phony=False, command=None):

    command: (optional) command name to generate unambiguous labels

    if actions:

      self.WriteLn("%s: TOOLSET := $(TOOLSET)" % outputs[0])

    force_append = ' FORCE_DO_CMD' if force else ''

 

      # Order only rule: Just write a simple rule.

      # TODO(evanm): just make order_only a list of deps instead of this hack.

      self.WriteLn('%s: | %s%s' %

                   (' '.join(outputs), ' '.join(inputs), force_append))

    elif len(outputs) == 1:

      # Regular rule, one output: Just write a simple rule.

      self.WriteLn('%s: %s%s' % (outputs[0], ' '.join(inputs), force_append))

    else:

      # Regular rule, more than one output: Multiple outputs are tricky in

      # make. We will write three rules:

      # - All outputs depend on an intermediate file.

      # - Make .INTERMEDIATE depend on the intermediate.

      # - The intermediate file depends on the inputs and executes the

      #   actual command.

      # - The intermediate recipe will 'touch' the intermediate file.

      # - The multi-output rule will have an do-nothing recipe.

      intermediate = "%s.intermediate" % (command if command else self.target)

      self.WriteLn('%s: %s' % (' '.join(outputs), intermediate))

      self.WriteLn('\t%s' % '@:');

      self.WriteLn('%s: %s' % ('.INTERMEDIATE', intermediate))

      self.WriteLn('%s: %s%s' %

                   (intermediate, ' '.join(inputs), force_append))

      actions.insert(0, '$(call do_cmd,touch)')

 

      output_file = os.path.join(

          options.depth, options.generator_output, base_path, base_name)

    makefile_path = os.path.join(

        options.toplevel_dir, options.generator_output, makefile_name)

        'flock': './gyp-flock-tool flock',

  elif flavor == 'aix':

    header_params.update({

        'link_commands': LINK_COMMANDS_AIX,

        'flock': './gyp-flock-tool flock',

        'flock_index': 2,

    })

      env_key = key.replace('.', '_')  # CC.host -> CC_host

      if env_key in os.environ:

        value = os.environ[env_key]

  gyp.common.EnsureDirExists(makefile_path)

        "make_global_settings needs to be the same for all targets. %s vs. %s" %

        (this_make_global_settings, make_global_settings))