%PDF- %PDF-
Mini Shell

Mini Shell

Direktori : /lib/node_modules/npm/node_modules.bundled/node-gyp/gyp/pylib/gyp/generator/
Upload File :
Create Path :
Current File : //lib/node_modules/npm/node_modules.bundled/node-gyp/gyp/pylib/gyp/generator/make.pyo

�
vפ\c@sbddlZddlZddlZddlZddlZddlZddlZddlmZddlmZidd6dd6dd6dd	6d
d6dd
6dd6dd6dd6dd6dd6dd6dd6dd6Z	e
Zea
gagagaead�Zd�Zd Zd!Zd"Zd#Zd$Zd%ed&ed'ed(ed)ed*Zd+Zd,�Zd-Zd.Zd/Zd0Z id1d26d3d46d3d56d3d66d1d76d1d86Z!d9�Z"d:�Z#d;�Z$d<�Z%d=�Z&d>�Z'd?�Z(d@�Z)da*dA�Z+dBdC�Z,dD�Z-iZ.iZ/dEe0fdF��YZ1dG�Z2dH�Z3dI�Z4dS(Ji����N(tGetEnvironFallback(tGypErrorttEXECUTABLE_PREFIXtEXECUTABLE_SUFFIXtlibtSTATIC_LIB_PREFIXtSHARED_LIB_PREFIXs.atSTATIC_LIB_SUFFIXs $(obj).$(TOOLSET)/$(TARGET)/genitINTERMEDIATE_DIRs
$(obj)/gentSHARED_INTERMEDIATE_DIRs$(builddir)tPRODUCT_DIRs%(INPUT_ROOT)stRULE_INPUT_ROOTs%(INPUT_DIRNAME)stRULE_INPUT_DIRNAMEs
$(abspath $<)tRULE_INPUT_PATHs$(suffix $<)tRULE_INPUT_EXTs$(notdir $<)tRULE_INPUT_NAMEs$(BUILDTYPE)tCONFIGURATION_NAMEcCs+tjj|�}|dkr�|jdd�|jdd�|jdtd�|jdtd�dd	ljj}t|d
g�a	t|dg�a
t|dg�atj
id
d6dd6�n[|}|dkr�d}n|jd|�|jdd�|jdd�|jdd�d	S(sDCalculate additional variables for use in the build (called by gyp).tmactOStSHARED_LIB_SUFFIXs.dylibtSHARED_LIB_DIRRtLIB_DIRi����Nt+generator_additional_non_configuration_keyst"generator_additional_path_sectionst!generator_extra_sources_for_rulestobjcs.mtobjcxxs.mmtandroidtlinuxs.sos$(builddir)/lib.$(TOOLSET)s$(obj).$(TOOLSET)(tgyptcommont	GetFlavort
setdefaulttgenerator_default_variablestgyp.generator.xcodet	generatortxcodetgetattrRRRtCOMPILABLE_EXTENSIONStupdate(tdefault_variablestparamstflavortxcode_generatortoperating_system((sW/usr/lib/node_modules/npm/node_modules.bundled/node-gyp/gyp/pylib/gyp/generator/make.pytCalculateVariables@s.			cCs�|jdi�}|jdd	�}|r3tan|djpJ|dj}|jdd�}tjjtjj	||d��}i|djd6|d6a
d	S(
sOCalculate the generator specific info that gets fed to input (called by
  gyp).tgenerator_flagstandroid_ndk_versiontoptionst
output_dirtouttgypfilesttopleveltqualified_out_dirN(tgettNonetTruet#generator_wants_sorted_dependenciestgenerator_outputttoplevel_dirtostpathtnormpathtjointgenerator_filelist_paths(R*R/R0R2t
builddir_nameR6((sW/usr/lib/node_modules/npm/node_modules.bundled/node-gyp/gyp/pylib/gyp/generator/make.pytCalculateGeneratorInputInfobs	

t?s�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)) crsT $@ $(filter %.o,$^)

# Due to circular dependencies between libraries :(, we wrap the
# special "figure out circular dependencies" flags around the entire
# input list during linking.
quiet_cmd_link = LINK($(TOOLSET)) $@
cmd_link = $(LINK.$(TOOLSET)) $(GYP_LDFLAGS) $(LDFLAGS.$(TOOLSET)) -o $@ -Wl,--start-group $(LD_INPUTS) -Wl,--end-group $(LIBS)

# We support two kinds of shared objects (.so):
# 1) shared_library, which is just bundling together many dependent libraries
# into a link line.
# 2) loadable_module, which is generating a module intended for dlopen().
#
# They differ only slightly:
# In the former case, we want to package all dependent code into the .so.
# In the latter case, we want to package just the API exposed by the
# outermost module.
# This means shared_library uses --whole-archive, while loadable_module doesn't.
# (Note that --whole-archive is incompatible with the --start-group used in
# normal linking.)

# Other shared-object link notes:
# - Set SONAME to the library filename so our binaries don't reference
# the local, absolute paths used on the link command-line.
quiet_cmd_solink = SOLINK($(TOOLSET)) $@
cmd_solink = $(LINK.$(TOOLSET)) -shared $(GYP_LDFLAGS) $(LDFLAGS.$(TOOLSET)) -Wl,-soname=$(@F) -o $@ -Wl,--whole-archive $(LD_INPUTS) -Wl,--no-whole-archive $(LIBS)

quiet_cmd_solink_module = SOLINK_MODULE($(TOOLSET)) $@
cmd_solink_module = $(LINK.$(TOOLSET)) -shared $(GYP_LDFLAGS) $(LDFLAGS.$(TOOLSET)) -Wl,-soname=$(@F) -o $@ -Wl,--start-group $(filter-out FORCE_DO_CMD, $^) -Wl,--end-group $(LIBS)
shquiet_cmd_alink = LIBTOOL-STATIC $@
cmd_alink = rm -f $@ && ./gyp-mac-tool filter-libtool libtool $(GYP_LIBTOOLFLAGS) -static -o $@ $(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)) -bundle $(GYP_LDFLAGS) $(LDFLAGS.$(TOOLSET)) -o $@ $(filter-out FORCE_DO_CMD, $^) $(LIBS)
s�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)) crsT $@ $(filter %.o,$^)

# Due to circular dependencies between libraries :(, we wrap the
# special "figure out circular dependencies" flags around the entire
# input list during linking.
quiet_cmd_link = LINK($(TOOLSET)) $@
quiet_cmd_link_host = LINK($(TOOLSET)) $@
cmd_link = $(LINK.$(TOOLSET)) $(GYP_LDFLAGS) $(LDFLAGS.$(TOOLSET)) -o $@ -Wl,--start-group $(LD_INPUTS) -Wl,--end-group $(LIBS)
cmd_link_host = $(LINK.$(TOOLSET)) $(GYP_LDFLAGS) $(LDFLAGS.$(TOOLSET)) -o $@ $(LD_INPUTS) $(LIBS)

# Other shared-object link notes:
# - Set SONAME to the library filename so our binaries don't reference
# the local, absolute paths used on the link command-line.
quiet_cmd_solink = SOLINK($(TOOLSET)) $@
cmd_solink = $(LINK.$(TOOLSET)) -shared $(GYP_LDFLAGS) $(LDFLAGS.$(TOOLSET)) -Wl,-soname=$(@F) -o $@ -Wl,--whole-archive $(LD_INPUTS) -Wl,--no-whole-archive $(LIBS)

quiet_cmd_solink_module = SOLINK_MODULE($(TOOLSET)) $@
cmd_solink_module = $(LINK.$(TOOLSET)) -shared $(GYP_LDFLAGS) $(LDFLAGS.$(TOOLSET)) -Wl,-soname=$(@F) -o $@ -Wl,--start-group $(filter-out FORCE_DO_CMD, $^) -Wl,--end-group $(LIBS)
quiet_cmd_solink_module_host = SOLINK_MODULE($(TOOLSET)) $@
cmd_solink_module_host = $(LINK.$(TOOLSET)) -shared $(GYP_LDFLAGS) $(LDFLAGS.$(TOOLSET)) -Wl,-soname=$(@F) -o $@ $(filter-out FORCE_DO_CMD, $^) $(LIBS)
s�quiet_cmd_alink = AR($(TOOLSET)) $@
cmd_alink = rm -f $@ && $(AR.$(TOOLSET)) -X32_64 crs $@ $(filter %.o,$^)

quiet_cmd_alink_thin = AR($(TOOLSET)) $@
cmd_alink_thin = rm -f $@ && $(AR.$(TOOLSET)) -X32_64 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)
s	# We borrow heavily from the kernel build setup, though we are simpler since
# we don't have Kconfig tweaking settings on us.

# The implicit make rules have it looking for RCS files, among other things.
# We instead explicitly write all the rules we care about.
# It's even quicker (saves ~200ms) to pass -r on the command line.
MAKEFLAGS=-r

# The source directory tree.
srcdir := %(srcdir)s
abs_srcdir := $(abspath $(srcdir))

# The name of the builddir.
builddir_name ?= %(builddir)s

# The V=1 flag on command line makes us verbosely print command lines.
ifdef V
  quiet=
else
  quiet=quiet_
endif

# Specify BUILDTYPE=Release on the command line for a release build.
BUILDTYPE ?= %(default_configuration)s

# Directory all our build output goes into.
# Note that this must be two directories beneath src/ for unit tests to pass,
# as they reach into the src/ directory for data with relative paths.
builddir ?= $(builddir_name)/$(BUILDTYPE)
abs_builddir := $(abspath $(builddir))
depsdir := $(builddir)/.deps

# Object output directory.
obj := $(builddir)/obj
abs_obj := $(abspath $(obj))

# We build up a list of every single one of the targets so we can slurp in the
# generated dependency rule Makefiles in one pass.
all_deps :=

%(make_global_settings)s

CC.target ?= %(CC.target)s
CFLAGS.target ?= $(CPPFLAGS) $(CFLAGS)
CXX.target ?= %(CXX.target)s
CXXFLAGS.target ?= $(CPPFLAGS) $(CXXFLAGS)
LINK.target ?= %(LINK.target)s
LDFLAGS.target ?= $(LDFLAGS)
AR.target ?= $(AR)

# C++ apps need to be linked with g++.
LINK ?= $(CXX.target)

# TODO(evan): move all cross-compilation logic to gyp-time so we don't need
# to replicate this environment fallback in make as well.
CC.host ?= %(CC.host)s
CFLAGS.host ?= $(CPPFLAGS_host) $(CFLAGS_host)
CXX.host ?= %(CXX.host)s
CXXFLAGS.host ?= $(CPPFLAGS_host) $(CXXFLAGS_host)
LINK.host ?= %(LINK.host)s
LDFLAGS.host ?=
AR.host ?= %(AR.host)s

# Define a dir function that can handle spaces.
# http://www.gnu.org/software/make/manual/make.html#Syntax-of-Functions
# "leading spaces cannot appear in the text of the first argument as written.
# These characters can be put into the argument value by variable substitution."
empty :=
space := $(empty) $(empty)

# http://stackoverflow.com/questions/1189781/using-make-dir-or-notdir-on-a-path-with-spaces
replace_spaces = $(subst $(space),s ,$1)
unreplace_spaces = $(subst s�,$(space),$1)
dirx = $(call unreplace_spaces,$(dir $(call replace_spaces,$1)))

# Flags to make gcc output dependency info.  Note that you need to be
# careful here to use the flags that ccache and distcc can understand.
# We write to a dep file on the side first and then rename at the end
# so we can't end up with a broken dep file.
depfile = $(depsdir)/$(call replace_spaces,$@).d
DEPFLAGS = -MMD -MF $(depfile).raw

# We have to fixup the deps output in a few ways.
# (1) the file output should mention the proper .o file.
# ccache or distcc lose the path to the target, so we convert a rule of
# the form:
#   foobar.o: DEP1 DEP2
# into
#   path/to/foobar.o: DEP1 DEP2
# (2) we want missing files not to cause us to fail to build.
# We want to rewrite
#   foobar.o: DEP1 DEP2 \
#               DEP3
# to
#   DEP1:
#   DEP2:
#   DEP3:
# so if the files are missing, they're just considered phony rules.
# We have to do some pretty insane escaping to get those backslashes
# and dollar signs past make, the shell, and sed at the same time.
# Doesn't work with spaces, but that's fine: .d files have spaces in
# their names replaced with other characters.
define fixup_dep
# The depfile may not exist if the input file didn't have any #includes.
touch $(depfile).raw
# Fixup path as in (1).
sed -e "s|^$(notdir $@)|$@|" $(depfile).raw >> $(depfile)
# Add extra rules as in (2).
# We remove slashes and replace spaces with new lines;
# remove blank lines;
# delete the first line and append a colon to the remaining lines.
sed -e 's|\\||' -e 'y| |\n|' $(depfile).raw |\
  grep -v '^$$'                             |\
  sed -e 1d -e 's|$$|:|'                     \
    >> $(depfile)
rm $(depfile).raw
endef

# Command definitions:
# - cmd_foo is the actual command to run;
# - quiet_cmd_foo is the brief-output summary of the command.

quiet_cmd_cc = CC($(TOOLSET)) $@
cmd_cc = $(CC.$(TOOLSET)) $(GYP_CFLAGS) $(DEPFLAGS) $(CFLAGS.$(TOOLSET)) -c -o $@ $<

quiet_cmd_cxx = CXX($(TOOLSET)) $@
cmd_cxx = $(CXX.$(TOOLSET)) $(GYP_CXXFLAGS) $(DEPFLAGS) $(CXXFLAGS.$(TOOLSET)) -c -o $@ $<
%(extra_commands)s
quiet_cmd_touch = TOUCH $@
cmd_touch = touch $@

quiet_cmd_copy = COPY $@
# send stderr to /dev/null to ignore messages when linking directories.
cmd_copy = rm -rf "$@" && cp %(copy_archive_args)s "$<" "$@"

%(link_commands)s

# Define an escape_quotes function to escape single quotes.
# This allows us to handle quotes properly as long as we always use
# use single quotes and escape_quotes.
escape_quotes = $(subst ','\'',$(1))
# This comment is here just to include a ' to unconfuse syntax highlighting.
# Define an escape_vars function to escape '$' variable syntax.
# This allows us to read/write command lines with shell variables (e.g.
# $LD_LIBRARY_PATH), without triggering make substitution.
escape_vars = $(subst $$,$$$$,$(1))
# Helper that expands to a shell command to echo a string exactly as it is in
# make. This uses printf instead of echo because printf's behaviour with respect
# to escape sequences is more portable than echo's across different shells
# (e.g., dash, bash).
exact_echo = printf '%%s\n' '$(call escape_quotes,$(1))'

# Helper to compare the command we're about to run against the command
# we logged the last time we ran the command.  Produces an empty
# string (false) when the commands match.
# Tricky point: Make has no string-equality test function.
# The kernel uses the following, but it seems like it would have false
# positives, where one string reordered its arguments.
#   arg_check = $(strip $(filter-out $(cmd_$(1)), $(cmd_$@)) \
#                       $(filter-out $(cmd_$@), $(cmd_$(1))))
# We instead substitute each for the empty string into the other, and
# say they're equal if both substitutions produce the empty string.
# .d files contain sa instead of spaces, take that into account.
command_changed = $(or $(subst $(cmd_$(1)),,$(cmd_$(call replace_spaces,$@))),\
                       $(subst $(cmd_$(call replace_spaces,$@)),,$(cmd_$(1))))

# Helper that is non-empty when a prerequisite changes.
# Normally make does this implicitly, but we force rules to always run
# so we can check their command lines.
#   $? -- new prerequisites
#   $| -- order-only dependencies
prereq_changed = $(filter-out FORCE_DO_CMD,$(filter-out $|,$?))

# Helper that executes all postbuilds until one fails.
define do_postbuilds
  @E=0;\
  for p in $(POSTBUILDS); do\
    eval $$p;\
    E=$$?;\
    if [ $$E -ne 0 ]; then\
      break;\
    fi;\
  done;\
  if [ $$E -ne 0 ]; then\
    rm -rf "$@";\
    exit $$E;\
  fi
endef

# do_cmd: run a command via the above cmd_foo names, if necessary.
# Should always run for a given target to handle command-line changes.
# Second argument, if non-zero, makes it do asm/C/C++ dependency munging.
# Third argument, if non-zero, makes it do POSTBUILDS processing.
# Note: We intentionally do NOT call dirx for depfile, since it contains s* for
# spaces already and dirx strips the s� characters.
define do_cmd
$(if $(or $(command_changed),$(prereq_changed)),
  @$(call exact_echo,  $($(quiet)cmd_$(1)))
  @mkdir -p "$(call dirx,$@)" "$(dir $(depfile))"
  $(if $(findstring flock,$(word %(flock_index)d,$(cmd_$1))),
    @$(cmd_$(1))
    @echo "  $(quiet_cmd_$(1)): Finished",
    @$(cmd_$(1))
  )
  @$(call exact_echo,$(call escape_vars,cmd_$(call replace_spaces,$@) := $(cmd_$(1)))) > $(depfile)
  @$(if $(2),$(fixup_dep))
  $(if $(and $(3), $(POSTBUILDS)),
    $(call do_postbuilds)
  )
)
endef

# Declare the "%(default_target)s" target first so it is the default,
# even though we don't have the deps yet.
.PHONY: %(default_target)s
%(default_target)s:

# make looks for ways to re-generate included makefiles, but in our case, we
# don't have a direct way. Explicitly telling make that it has nothing to do
# for them makes it go faster.
%%.d: ;

# Use FORCE_DO_CMD to force a target to run.  Should be coupled with
# do_cmd.
.PHONY: FORCE_DO_CMD
FORCE_DO_CMD:

s�
quiet_cmd_objc = CXX($(TOOLSET)) $@
cmd_objc = $(CC.$(TOOLSET)) $(GYP_OBJCFLAGS) $(DEPFLAGS) -c -o $@ $<

quiet_cmd_objcxx = CXX($(TOOLSET)) $@
cmd_objcxx = $(CXX.$(TOOLSET)) $(GYP_OBJCXXFLAGS) $(DEPFLAGS) -c -o $@ $<

# Commands for precompiled header files.
quiet_cmd_pch_c = CXX($(TOOLSET)) $@
cmd_pch_c = $(CC.$(TOOLSET)) $(GYP_PCH_CFLAGS) $(DEPFLAGS) $(CXXFLAGS.$(TOOLSET)) -c -o $@ $<
quiet_cmd_pch_cc = CXX($(TOOLSET)) $@
cmd_pch_cc = $(CC.$(TOOLSET)) $(GYP_PCH_CXXFLAGS) $(DEPFLAGS) $(CXXFLAGS.$(TOOLSET)) -c -o $@ $<
quiet_cmd_pch_m = CXX($(TOOLSET)) $@
cmd_pch_m = $(CC.$(TOOLSET)) $(GYP_PCH_OBJCFLAGS) $(DEPFLAGS) -c -o $@ $<
quiet_cmd_pch_mm = CXX($(TOOLSET)) $@
cmd_pch_mm = $(CC.$(TOOLSET)) $(GYP_PCH_OBJCXXFLAGS) $(DEPFLAGS) -c -o $@ $<

# gyp-mac-tool is written next to the root Makefile by gyp.
# Use $(4) for the command, since $(2) and $(3) are used as flag by do_cmd
# already.
quiet_cmd_mac_tool = MACTOOL $(4) $<
cmd_mac_tool = ./gyp-mac-tool $(4) $< "$@"

quiet_cmd_mac_package_framework = PACKAGE FRAMEWORK $@
cmd_mac_package_framework = ./gyp-mac-tool package-framework "$@" $(4)

quiet_cmd_infoplist = INFOPLIST $@
cmd_infoplist = $(CC.$(TOOLSET)) -E -P -Wno-trigraphs -x c $(INFOPLIST_DEFINES) "$<" -o "$@"
cCs�ttj�dtj�}|jd�x4|D],}|jd|�|jdt|�q/W|jd�x4|D],}|jd|�|jdt|�qsW|jd�x4|D],}|jd|�|jdt|�q�W|jd�dS(	Ntkeys1# Suffix rules, putting all outputs into $(obj).
s4$(obj).$(TOOLSET)/%%.o: $(srcdir)/%%%s FORCE_DO_CMD
s	@$(call do_cmd,%s,1)
s,
# Try building from generated source, too.
s<$(obj).$(TOOLSET)/%%.o: $(obj).$(TOOLSET)/%%%s FORCE_DO_CMD
s
s1$(obj).$(TOOLSET)/%%.o: $(obj)/%%%s FORCE_DO_CMD
(tsortedR'tkeyststrtlowertwrite(twritert
extensionstext((sW/usr/lib/node_modules/npm/node_modules.bundled/node-gyp/gyp/pylib/gyp/generator/make.pytWriteRootHeaderSuffixRules�s





s1# Suffix rules, putting all outputs into $(obj).
s+# Try building from generated source, too.
s�# "all" is a concatenation of the "all" targets from all the included
# sub-makefiles. This is just here to clarify.
all:

# Add in dependency-tracking rules.  $(all_deps) is the list of every single
# target in our tree. Only consider the ones with .d (dependency) info:
d_files := $(wildcard $(foreach f,$(all_deps),$(depsdir)/$(f).d))
ifneq ($(d_files),)
  include $(d_files)
endif
s/# This file is generated by gyp; do not edit.

tccs.ctcxxs.ccs.cpps.cxxs.ss.Scs/x(�fd�tD�D]}|rtSqWtS(s:Return true if the file is compilable (should be in OBJS).c3s|]}�j|�VqdS(N(tendswith(t.0te(tfilename(sW/usr/lib/node_modules/npm/node_modules.bundled/node-gyp/gyp/pylib/gyp/generator/make.pys	<genexpr>1s(R'R9tFalse(RTtres((RTsW/usr/lib/node_modules/npm/node_modules.bundled/node-gyp/gyp/pylib/gyp/generator/make.pyt
Compilable/scCs
|jd�S(sAReturn true if the file is linkable (should be on the link line).s.o(RQ(RT((sW/usr/lib/node_modules/npm/node_modules.bundled/node-gyp/gyp/pylib/gyp/generator/make.pytLinkable7scCstjj|�ddS(s1Translate a compilable filename to its .o target.is.o(R=R>tsplitext(RT((sW/usr/lib/node_modules/npm/node_modules.bundled/node-gyp/gyp/pylib/gyp/generator/make.pytTarget<scCsd|jdd�dS(s�Quotes an argument so that it will be interpreted literally by a POSIX
     shell. Taken from
     http://stackoverflow.com/questions/35817/whats-the-best-way-to-escape-ossystem-calls-in-python
     t's'\''(treplace(ts((sW/usr/lib/node_modules/npm/node_modules.bundled/node-gyp/gyp/pylib/gyp/generator/make.pytEscapeShellArgumentAscCs|jdd�S(srMake has its own variable expansion syntax using $. We must escape it for
     string to be interpreted literally.t$s$$(R\(R]((sW/usr/lib/node_modules/npm/node_modules.bundled/node-gyp/gyp/pylib/gyp/generator/make.pytEscapeMakeVariableExpansionIscCs(t|�}t|�}|jdd�S(sBEscapes a CPP define so that it will reach the compiler unaltered.t#s\#(R^R`R\(R]((sW/usr/lib/node_modules/npm/node_modules.bundled/node-gyp/gyp/pylib/gyp/generator/make.pytEscapeCppDefineOscCs-d|kr)d|jdd�d}n|S(sSTODO: Should this ideally be replaced with one or more of the above
     functions?t"s\"(R\(tstring((sW/usr/lib/node_modules/npm/node_modules.bundled/node-gyp/gyp/pylib/gyp/generator/make.pytQuoteIfNecessaryXscCstjdd|�S(sGConvert a string to a value that is acceptable as a make variable name.s
[^a-zA-Z0-9_]t_(tretsub(Rd((sW/usr/lib/node_modules/npm/node_modules.bundled/node-gyp/gyp/pylib/gyp/generator/make.pytStringToMakefileVariable`scCs.d|kr|Stjj|�r&|St|S(s,Convert a path to its source directory form.s$((R=R>tisabst
srcdir_prefix(R>((sW/usr/lib/node_modules/npm/node_modules.bundled/node-gyp/gyp/pylib/gyp/generator/make.pyt	Sourceifyfs
s\ cCs|jd|�S(Nt (R\(R]tquote((sW/usr/lib/node_modules/npm/node_modules.bundled/node-gyp/gyp/pylib/gyp/generator/make.pytQuoteSpacesosc

Cs|jdd�dkrdSi}xi|D]a}tjj|�\}}|dk}|s_q)ntjj|�}|j|g�j|�q)Wd}xL|j�D]>\}}	t	|	�d
kr�|d|dj
|	�f7}q�q�W|rd|d|ddGHtd��ndS(s�Makes sure if duplicate basenames are not specified in the source list.

  Arguments:
    spec: The target dictionary containing the properties of the target.
  ttypetstatic_libraryNs.cs.ccs.cpps.cxxs.ms.mms.ss.SRis	  %s: %s
Rms<static library %s has several files with the same basename:
ttarget_nameslibtool on OS X will generates warnings for them.s6Duplicate basenames in sources section, see list above(s.cs.ccs.cpps.cxxs.ms.mms.ss.S(R7R8R=R>RYtbasenameR!tappendt	iteritemstlenR@R(
tspectall_sourcest	basenamestsourcetnameRMtis_compiled_fileRsterrortfiles((sW/usr/lib/node_modules/npm/node_modules.bundled/node-gyp/gyp/pylib/gyp/generator/make.pyt_ValidateSourcesForOSXts&
	$tMakefileWritercBsLeZdZd�Zd�Zd�Zd�Zd�Zd�Zd�Z	d�Z
d	�Zd
�Zd�Z
d�Zd
�Zd�Zd�Zd�Zd�Zd�Zd!ded�Zd!ed�Zd!d!eeed!d�Zd�Zdd�Zd!d�Zd�Zd�Zd�Z d�Z!d�Z"d�Z#d �Z$RS("s�MakefileWriter packages up the writing of one target-specific foobar.mk.

  Its only real entry point is Write(), and is mostly used for namespacing.
  cCs�||_||_i|_i|_i|_x�tj�D]u}|jjid|t|f|6�|jjid|t|f|6�|jjid|t|f|6�q:WdS(NsT$(obj).$(TOOLSET)/$(TARGET)/%%.o: $(srcdir)/%%%s FORCE_DO_CMD
	@$(call do_cmd,%s,1)
s\$(obj).$(TOOLSET)/$(TARGET)/%%.o: $(obj).$(TOOLSET)/%%%s FORCE_DO_CMD
	@$(call do_cmd,%s,1)
sQ$(obj).$(TOOLSET)/$(TARGET)/%%.o: $(obj)/%%%s FORCE_DO_CMD
	@$(call do_cmd,%s,1)
(R/R+tsuffix_rules_srcdirtsuffix_rules_objdir1tsuffix_rules_objdir2R'RGR((tselfR/R+RM((sW/usr/lib/node_modules/npm/node_modules.bundled/node-gyp/gyp/pylib/gyp/generator/make.pyt__init__�s					cs�tjj|�t|d��_�jjt�|�_|�_|d�_	|d�_
|d�_tjj
�j|��_�jdkr�tjj|��_n	d�_�j|�\}}g}	g}
g}g}g}
�jr�j|��_�j|��_n�j|��_�_t|jdd���_d�_�jsq�j
�jkr�tjj�j��_�j �}n�j�_�j}�j!d�j��j!d�j	�d
|kr�j"|d
|
|	||�nd|kr-�j#|d|
|	||�nd|krS�j$|d|	|�n�jr�|jdg�|}�j%||
��j&|
�n|jdg�|
}|r?�jdkr�t'||�n�j(||||	||tjj)�j�fd��j*��t+t,|�}|r?�j!t-�t.g|D]}tjj/|�d^q9�}x4|D],}|�j0kre�j!�j0|�qeqeW�j!t1�x4|D],}|�j2kr��j!�j2|�q�q�Wx4|D],}|�j3kr��j!�j3|�q�q�W�j!d��jr<|
j4�j�q<q?n�j5||||||
|	|�|t6|<�j
dkr��jt7|<n�j8jdd�r��j9�j	||�n�jj:�dS(s�The main entry point: writes a .mk file for a single target.

    Arguments:
      qualified_target: target we're generating
      base_path: path relative to source root we're building in, used to resolve
                 target-relative paths
      output_filename: output .mk file name to write
      spec, configs: gyp info
      part_of_all: flag indicating this target is part of 'all'
    twRrRpttoolsetRtstandalone_static_libraryit
executabletloadable_moduletshared_librarysTOOLSET := s
TARGET := tactionstrulestcopiestmac_bundle_resourcestsourcescst�j|��S(N(Rlt
Absolutify(tp(R�(sW/usr/lib/node_modules/npm/node_modules.bundled/node-gyp/gyp/pylib/gyp/generator/make.pyt<lambda>sis!# End of this set of suffix rulesRqR0N(s
executableR�R�(sstatic_libraryR�(;RRtEnsureDirExiststopentfpRJtheadertqualified_targetR>ttargetRpR�txcode_emulationtIsMacBundleR+t
is_mac_bundlet
XcodeSettingstxcode_settingsR8tComputeDepstComputeMacBundleOutputtoutputtComputeMacBundleBinaryOutputt
output_binaryt
ComputeOutputtboolR7tis_standalone_static_libraryt_INSTALLABLE_TARGETSR=Rstaliast_InstallableTargetInstallPathtWriteLntWriteActionst
WriteRulestWriteCopiestWriteMacBundleResourcestWriteMacInfoPlistRtWriteSourcestMacPrefixHeadertPchifytfilterRWt#SHARED_HEADER_SUFFIX_RULES_COMMENT1tsetRYR�t#SHARED_HEADER_SUFFIX_RULES_COMMENT2R�R�RttWriteTargetttarget_outputsttarget_link_depsR/tWriteAndroidNdkModuleRuletclose(R�R�t	base_pathtoutput_filenameRwtconfigstpart_of_alltdepst	link_depst
extra_outputst
extra_sourcestextra_link_depstextra_mac_bundle_resourcestmac_bundle_depstinstall_pathtall_mac_bundle_resourcesRxR�R]RLRM((R�sW/usr/lib/node_modules/npm/node_modules.bundled/node-gyp/gyp/pylib/gyp/generator/make.pytWrite�s�		


					

		

/




	

cCs�tjj|�t|d�|_|jjt�|jdtj	j
tj	j|�|��|jd�|jd�|r�d|}n|jd|dj
|�f�|jj�dS(	s�Write a "sub-project" Makefile.

    This is a small, wrapper Makefile that calls the top-level Makefile to build
    the targets from a single gyp file (i.e. a sub-project).

    Arguments:
      output_filename: sub-project Makefile name to write
      makefile_path: path to the top-level Makefile
      targets: list of "all" targets for this sub-project
      build_dir: build output directory, relative to the sub-project
    R�sexport builddir_name ?= %ss.PHONY: allsall:s -C s
	$(MAKE)%s %sRmN(
RRR�R�R�RJR�R�R=R>R@tdirnameR�(R�R�t
makefile_pathttargetst	build_dir((sW/usr/lib/node_modules/npm/node_modules.bundled/node-gyp/gyp/pylib/gyp/generator/make.pytWriteSubMakeBs	#


 c	Csy|j�}x\|D]T}td|j|df�}|jd|d�|d}	|d}
t�}x:|
D]2}tjj|�d}
|
ro|j|
�qoqoWt	|j
dt��r�||
7}nt	|j
dt��r�||
7}n|d	}|jd
kr3g|D]}t
jj||�^q}nt
jj|�}d|kro|jd||df�n|jd||f�t|�dkr�d
dj|�d|}ndt|jp�d�}|jd|j�}|jd|j�}|jd|||f�|j�t|j|
�}
|jdt|
d��|jdt|
d��|j|
d|j��x|	D]}q�Wx|
D]}q�Wg|
D]}t
jj||�^q�}
g|	D]}t
jj||�^q�}	|j|
ttt|j|	��d|d|�d|}|jd|dj|
�f�|jd|�|j�qW|j�dS(s�Write Makefile code for any 'actions' from the gyp input.

    extra_sources: a list that will be filled in with newly generated source
                   files, if any
    extra_outputs: a list that will be filled in with any outputs of these
                   actions (used to make other pieces dependent on these
                   actions)
    part_of_all: flag indicating this target is part of 'all'
    s%s_%staction_names### Rules for action "%s":tinputstoutputsitprocess_outputs_as_sourcest'process_outputs_as_mac_bundle_resourcestactionRtmessagesquiet_cmd_%s = ACTION %s $@smkdir -p %sRms; scd %s; t.s	$(TARGET)stcmd_%s = LD_LIBRARY_PATH=$(builddir)/lib.host:$(builddir)/lib.target:$$LD_LIBRARY_PATH; export LD_LIBRARY_PATH; %s%ss%s: obj := $(abs_obj)s%s: builddir := $(abs_builddir)R�tcommandsaction_%s_outputss%s := %ss$(%s)N(tGetSortedXcodeEnvRiR�R�R�R=R>tsplittaddtintR7RUR+RR�t
ExpandEnvVarsRtEncodePOSIXShellListRvR@RlR\R�tmapR�RotWriteSortedXcodeEnvt
WriteDoCmdRt(R�R�R�R�R�R�tenvR�R{R�R�tdirsR3tdirtaction_commandsR�t	cd_actiontinputR�totitoutputs_variable((sW/usr/lib/node_modules/npm/node_modules.bundled/node-gyp/gyp/pylib/gyp/generator/make.pyR�]sb


	



(	
	

(($

 c 
Cs�|j�}x]|D]U}td|j|df�}d}	|jd|�g}
x�|jdg�D]�}t�}tjj|�\}
}tjj	|�\}}g|dD]}|j
|||
�^q�}x6|D].}tjj|�}|r�|j|�q�q�Wt
|jdt��r/||7}nt
|jdt��rT||7}nttt|j|g|jd	g���}d
||	fg}|dkr�|dg7}ng|D]}tjj||�^q�}g|D]}tjj||�^q�}t|j|�}|
|7}
|jd
|d�|jd|d�|j|||dd||	f�tjd�}x#|D]}tj|d|�}q�W|jddj|��g|dD]}|j
|||
�^q�}d}t|�dkrddj|�}ndt|jp%d�}|jdkrfg|D]}tjj||�^qB}ntjj|�}|jd|j�}|jd|j�}|jd|j�}|jdi|d6|d6|	d6|d6|d6�|jd i|	d6|d6�|j�|	d!7}	qfWd"|}|j |
|�|j!d#|�|jd$|�|j�qW|jd%�|jd�d&S('s�Write Makefile code for any 'rules' from the gyp input.

    extra_sources: a list that will be filled in with newly generated source
                   files, if any
    extra_outputs: a list that will be filled in with any outputs of these
                   rules (used to make other pieces dependent on these rules)
    part_of_all: flag indicating this target is part of 'all'
    s%s_%st	rule_nameis### Generated for rule %s:trule_sourcesR�R�R�R�s$(call do_cmd,%s_%d)tresources_grits@touch --no-create $@s%s: obj := $(abs_obj)s%s: builddir := $(abs_builddir)R�s%s_%ds\$\([^ ]* \$<\)Rsall_deps += %sRmR�s
mkdir -p %s; scd %s; R�Rs	$(TARGET)s�cmd_%(name)s_%(count)d = LD_LIBRARY_PATH=$(builddir)/lib.host:$(builddir)/lib.target:$$LD_LIBRARY_PATH; export LD_LIBRARY_PATH; %(cd_action)s%(mkdirs)s%(action)sR�tcounttmkdirsR{s9quiet_cmd_%(name)s_%(count)d = RULE %(name)s_%(count)d $@isrule_%s_outputss$(%s)s$### Finished generating for rule: %ss%### Finished generating for all rulesN("R�RiR�R�R7R�R=R>R�RYtExpandInputRootR�R�R�RUR�RlR�RR�R�t
WriteMakeRuleRgtcompileRhR@RvR+RR�R\R�t	WriteListRt( R�R�R�R�R�R�R�truleR{R�tall_outputstrule_sourceR�trule_source_dirnametrule_source_basenametrule_source_roottrule_source_extR3R�R�R�R�R�R�tvariables_with_spacesR�tacR�R�R�R�R�((sW/usr/lib/node_modules/npm/node_modules.bundled/node-gyp/gyp/pylib/gyp/generator/make.pyR��s�

	)


((

)(


cCsF|jd�t|jd�}g}x�|D]�}x�|dD]�}t|j|��}tjj|�d}t|jtjj|d|���}	|j	�}
t
jj|	|
�}	t
jj||
�}|j
|	g|gd|�|j|	�q>Wq-W|jd|djtt|��f�|jd	|�|j�d
S(sWrite Makefile code for any 'copies' from the gyp input.

    extra_outputs: a list that will be filled in with any outputs of this action
                   (used to make other pieces dependent on this action)
    part_of_all: flag indicating this target is part of 'all'
    s### Generated for copy rule.t_copiesR~itdestinationtcopys%s = %sRms$(%s)N(R�RiR�RlR�R=R>R�R@R�RR�R�R�RtR�Ro(R�R�R�R�tvariableR�R�R>RTR�R�((sW/usr/lib/node_modules/npm/node_modules.bundled/node-gyp/gyp/pylib/gyp/generator/make.pyR�As"

)cCs�|jd�x�tjjtd|jttt|j|���D]_\}}t	j
j|�\}}|dkrB|j|g|gddt
�|j|�qBqBWdS(s0Writes Makefile code for 'mac_bundle_resources'.s&### Generated for mac_bundle_resourcesRs	.xcassetssmac_tool,,,copy-bundle-resourceR�N(R�RR�tGetMacBundleResourcesR"R�R�RlR�R=R>RYR�R9Rt(R�t	resourcestbundle_depsR�RVRfRM((sW/usr/lib/node_modules/npm/node_modules.bundled/node-gyp/gyp/pylib/gyp/generator/make.pyR�gs

(cs�tjjtd�j�fd��\}}}}|s>dS|r�dtjj|�}�j||dddt	��j
|g|gdd	g�|}n�j|�jd
|���j
|g|gddt�|j|�dS(
s0Write Makefile code for bundle Info.plist files.Rcst�j|��S(N(RlR�(R�(R�(sW/usr/lib/node_modules/npm/node_modules.bundled/node-gyp/gyp/pylib/gyp/generator/make.pyR�zsNs$(obj).$(TOOLSET)/$(TARGET)/s: INFOPLIST_DEFINESs-Dtquoters$(call do_cmd,infoplist)s@plutil -convert xml1 $@ $@tadditional_settingssmac_tool,,,copy-info-plistR�(RR�tGetMacInfoPlistR"R�R=R>RsR�RbR�R�R�R�R9Rt(R�Rt
info_plistR3tdefinest	extra_envtintermediate_plist((R�sW/usr/lib/node_modules/npm/node_modules.bundled/node-gyp/gyp/pylib/gyp/generator/make.pyR�vs&	

	cCsx�t|j��D]�}||}	|j|	jd�d|dddt�|jdkr�|jj|�}
|jj|�}|jj	|�}|jj
|�}
|jj|�}n-|	jd�}
|	jd�}|	jd	�}|jd
�|j|
d|�|jd�|j|d
|�|jd�|j|d|�|jdkr�|jd�|j|
d|�|jd�|j|d|�n|	jd�}|r�t
tt
|j|��}n|j|d|dd�qWtt|�}t
|jt
|jt
t|���}|j|d�x|D]}q:W|jd�|jd�|j�|r�|jdg|dddt�n|r�|jdg|dddt�n|j||�}|r|jd�x.|D]&\}}}|jd ||f�q�W|jd!�n|r�|jd�|jd"�|jd#�|jd$|jd%�d&�|jd'|jd(�d)�|jdkr�|jd*|jd+�d,�|jd-|jd.�d/�q�n|j|j��|tt|�7}|j�d0S(1sWrite Makefile code for any 'sources' from the gyp input.
    These are source files necessary to build the current target.

    configs, deps, sources: input from gyp.
    extra_outputs: a list of extra outputs this action should be dependent on;
                   used to serialize action/rules before compilation
    extra_link_deps: a list that will be filled in with any outputs of
                     compilation (to be used in link lines)
    part_of_all: flag indicating this target is part of 'all'
    RsDEFS_%stprefixs-DRRtcflagstcflags_ct	cflags_ccs## Flags passed to all source files.s	CFLAGS_%ss# Flags passed to only C files.sCFLAGS_C_%ss!# Flags passed to only C++ files.sCFLAGS_CC_%ss"# Flags passed to only ObjC files.sCFLAGS_OBJC_%ss$# Flags passed to only ObjC++ files.sCFLAGS_OBJCC_%stinclude_dirssINCS_%ss-ItOBJSs?# Add to the list of files we specially track dependencies for.sall_deps += $(OBJS)s$(OBJS)tcomments6Make sure our dependencies are built before any of us.t
order_onlys1Make sure our actions/rules run before any of us.s:# Dependencies from obj files to their precompiled headerss%s: %ss%# End precompiled header dependenciessn# CFLAGS et al overrides must be target-local.
# See "Target-specific Variable Values" in the GNU Make manual.s$(OBJS): TOOLSET := $(TOOLSET)sD$(OBJS): GYP_CFLAGS := $(DEFS_$(BUILDTYPE)) $(INCS_$(BUILDTYPE)) %s tcs/$(CFLAGS_$(BUILDTYPE)) $(CFLAGS_C_$(BUILDTYPE))sF$(OBJS): GYP_CXXFLAGS := $(DEFS_$(BUILDTYPE)) $(INCS_$(BUILDTYPE)) %s ROs0$(CFLAGS_$(BUILDTYPE)) $(CFLAGS_CC_$(BUILDTYPE))sG$(OBJS): GYP_OBJCFLAGS := $(DEFS_$(BUILDTYPE)) $(INCS_$(BUILDTYPE)) %s tmsK$(CFLAGS_$(BUILDTYPE)) $(CFLAGS_C_$(BUILDTYPE)) $(CFLAGS_OBJC_$(BUILDTYPE))sI$(OBJS): GYP_OBJCXXFLAGS := $(DEFS_$(BUILDTYPE)) $(INCS_$(BUILDTYPE)) %s tmmsM$(CFLAGS_$(BUILDTYPE)) $(CFLAGS_CC_$(BUILDTYPE)) $(CFLAGS_OBJCC_$(BUILDTYPE))N(RFRGR�R7RbR+R�t	GetCflagst
GetCflagsCtGetCflagsCCt
GetCflagsObjCtGetCflagsObjCCR�R�RlR�R�RWt	ObjectifyRZR�R9tGetObjDependenciesRtt
GetIncludetWritePchTargetstGetPchBuildCommandsRX(R�R�R�R�R�R�R�tprecompiled_headert
confignametconfigRRR
tcflags_objctcflags_objcctincludest
compilabletobjstobjtpchdepsRztgch((sW/usr/lib/node_modules/npm/node_modules.bundled/node-gyp/gyp/pylib/gyp/generator/make.pyR��s�
"




'








	
	
	
	
cCs�|s
dSx�|D]�\}}}}idd6dd6dd6dd	6|}id
d6dd6dd6d
d	6|}|jd|||fd|�|jd||f�|jd|�|jd�|jd|�|jd�qWdS(s,Writes make rules to compile prefix headers.Ns$(CFLAGS_C_$(BUILDTYPE))Rs$(CFLAGS_CC_$(BUILDTYPE))ROs4$(CFLAGS_C_$(BUILDTYPE)) $(CFLAGS_OBJC_$(BUILDTYPE))Rs6$(CFLAGS_CC_$(BUILDTYPE)) $(CFLAGS_OBJCC_$(BUILDTYPE))RtGYP_PCH_CFLAGStGYP_PCH_CXXFLAGStGYP_PCH_OBJCFLAGStGYP_PCH_OBJCXXFLAGSs
%s: %s := %s sA$(DEFS_$(BUILDTYPE)) $(INCS_$(BUILDTYPE)) $(CFLAGS_$(BUILDTYPE)) s%s: %s FORCE_DO_CMDs	@$(call do_cmd,pch_%s,1)Rsall_deps += %s(R�(R�tpch_commandsR)t	lang_flagtlangR�textra_flagstvar_name((sW/usr/lib/node_modules/npm/node_modules.bundled/node-gyp/gyp/pylib/gyp/generator/make.pyR
s.
cCsN|jdkr+|jdkr+|jj�S|d}d}d}|jdkr||d d	krm|d}nd	}d
}n�|jdkr�|d d	kr�|d}nd	}d}nE|jdkr�d
|}n)|jdkr�dd|jd|fGHn|jd|�}|jd|�}|jd�}|rBd|}n|||S(s�Return the 'output basename' of a gyp spec.

    E.g., the loadable module 'foobar' in directory 'baz' will produce
      'libfoobar.so'
    RRqR�R�R�RrRiRs.as.sotnones%s.stamps,ERROR: What output file should be generated?RpR�tproduct_prefixtproduct_nametproduct_extensionR�(sstatic_librarys
executablesshared_librarysloadable_module(sloadable_modulesshared_library(R+RpR�tGetExecutablePathR7(R�RwR�t
target_prefixt
target_exttproduct_ext((sW/usr/lib/node_modules/npm/node_modules.bundled/node-gyp/gyp/pylib/gyp/generator/make.pytComputeOutputBasename.s6	


	
	

cCs+|jdko*|jdko*|jdkS(NR�RRqR�R�R�(sstatic_librarys
executablesshared_librarysloadable_module(R�R+Rp(R�((sW/usr/lib/node_modules/npm/node_modules.bundled/node-gyp/gyp/pylib/gyp/generator/make.pyt_InstallImmediatelyVs$cCsqtjjd|j|j�}|jdks:|j�rCd}n|jd|�}tjj||j|��S(s�Return the 'output' (full output path) of a gyp spec.

    E.g., the loadable module 'foobar' in directory 'baz' will produce
      '$(obj)/baz/libfoobar.so'
    s$(obj).R�s$(builddir)tproduct_dir(R=R>R@R�RpR<R7R;(R�RwR>((sW/usr/lib/node_modules/npm/node_modules.bundled/node-gyp/gyp/pylib/gyp/generator/make.pyR�[s
	cCs&td}tjj||jj��S(sDReturn the 'output' (full output path) to a bundle output directory.R(R"R=R>R@R�tGetWrapperName(R�RwR>((sW/usr/lib/node_modules/npm/node_modules.bundled/node-gyp/gyp/pylib/gyp/generator/make.pyR�js
cCs&td}tjj||jj��S(sAReturn the 'output' (full output path) to the binary in a bundle.R(R"R=R>R@R�R7(R�RwR>((sW/usr/lib/node_modules/npm/node_modules.bundled/node-gyp/gyp/pylib/gyp/generator/make.pyR�qs
cCs�g}g}d|kr�|jg|dD]}t|r)t|^q)�x2|dD]&}|tkrU|jt|�qUqUW|j|�ntjj|�tjj|�fS(s�Compute the dependencies of a gyp spec.

    Returns a tuple (deps, link_deps), where each is a list of
    filenames that will need to be put in front of make for either
    building (deps) or linking (link_deps).
    tdependencies(textendR�R�RtRRtuniquer(R�RwR�R�tdep((sW/usr/lib/node_modules/npm/node_modules.bundled/node-gyp/gyp/pylib/gyp/generator/make.pyR�wscCs&|j|jg|dddt�dS(NRs Build our special outputs first.R(R�R�R9(R�R�R�((sW/usr/lib/node_modules/npm/node_modules.bundled/node-gyp/gyp/pylib/gyp/generator/make.pytWriteDependencyOnExtraOutputs�scs`	�jd�|rE�j�j|��j||dddt�ni}�jdkr�x�t|j��D]�}	||	}
�jdkr<�j	j
|	td�fd��}tj
j�j�}�j	j|	ttjjtjj|�j���ttjjtjj|�j����}
|
r�|
||	<q�nS|
jd	g�}td
�|D��r�|jd�j�|jd�j�n|
jd
g�}|g|D]}d|^q�7}�j|d|	��jdkrm�j�j	j|	�d|	�qmqmW|jd�}|rZtj
j|�}�jdkrZ�j	j|�}qZn�j|d��jdt�j���jdt�j���jdkr��jdt�j��q�ng}�jdkr|r�|jd�n|jtjj |��n|r)�j!�j�j"��xA|D]9}	�jdt�j�|	tj
j#||	�f�q:W|j$dtj
j#d�jg��xDt%t&|��D]0}||j'd�s�t(||�||<q�q�W�jdt�j���jdt�j�dj|�f�n�j)r��j�j|��jt*t|�d��jdt�j���jdFkr��jd"�j	j+��n|r��jd#�ng}�jd$��jd%t�j��n|r�n�jd&kr��jd't�j�djt*t|��f��jd(krw�jd)krw�j,�jg|d*|d+|�qQ�j,�jg|d,|d+|�n��jd-krx|D]}q�W�jdGkr��j-r��j,�jg|d1|d+|�qQ�j,�jg|d2|d+|�n2�jd kr��jd't�j�djt*t|��f��j,�jg|d3|d+|�n��jd!kr
x|D]}q�W�jd(kr��jd)kr��j,�jg|d4|d+|�qQ�j,�jg|d5|d+|�nD�jdkrA�j,�jg|d6|d+|�nd7G�jGt.GH�jr��j�j.kr��j�j/kr��j�j.g�jgdd8d9t�|r��jd:g�j.gdd;d9t�q�n�j�j/ks��j-r\	�jd kr
d<}n�jd-kr"d=}nd&}�j0�}�jg}�jdkrmd>|krm�jd?krmn�j�j.g|gdd8d9t�|�jkr��j,|g�jgd@ddA|dB|�|j|�n�j�j1kr*	�j1�j.kr*	�j�j1g|ddC|d9t�n|r\	�jd:g|gddD|d9t�q\	ndES(Hs&Write Makefile code to produce the final target of the gyp spec.

    spec, configs: input from gyp.
    deps, link_deps: dependency lists; see ComputeDeps()
    extra_outputs: any extra outputs that our target should depend on
    part_of_all: flag indicating this target is part of 'all'
    s### Rules for final target.Rs4Preserve order dependency of special output on deps.RR3RRcst�j|��S(N(RlR�(R�(R�(sW/usr/lib/node_modules/npm/node_modules.bundled/node-gyp/gyp/pylib/gyp/generator/make.pyR��stldflagscss*|] }|jd�p!d|kVqdS(s.sos.so.N(RQ(RRRB((sW/usr/lib/node_modules/npm/node_modules.bundled/node-gyp/gyp/pylib/gyp/generator/make.pys	<genexpr>�ss-Wl,-rpath=\$$ORIGIN/lib.%s/s$-Wl,-rpath-link=\$(builddir)/lib.%s/tlibrary_dirss-L%ss
LDFLAGS_%ssLIBTOOLFLAGS_%st	librariestLIBSs*%s: GYP_LDFLAGS := $(LDFLAGS_$(BUILDTYPE))s%s: LIBS := $(LIBS)s4%s: GYP_LIBTOOLFLAGS := $(LIBTOOLFLAGS_$(BUILDTYPE))s!$(TARGET_POSTBUILDS_$(BUILDTYPE))s%s: TARGET_POSTBUILDS_%s := %sitcdR_s%s: builddir := $(abs_builddir)s%s: POSTBUILDS := %sRmtBUNDLE_DEPSs%s: $(BUNDLE_DEPS)R�R�s+	@$(call do_cmd,mac_package_framework,,,%s)s	@$(call do_postbuilds)s	@true  # No-op, used by testss
	@touch -c %sR�s%s: LD_INPUTS := %sthostRt	link_hostt
postbuildstlinkRqtopenbsdtnetbsdtwint
alink_thintalinktsolinktsolink_module_hostt
solink_modulettouchsWARNING: no output forsAdd target aliastphonytalls!Add target alias to "all" target.sshared librarysstatic libraryR=R�R�s Copy this to the %s output path.R�s!Short alias for building this %s.sAdd %s to "all" target.N(sshared_librarysloadable_module(smacRNRORP(2R�RCR�R�R9RpRFRGR+R�t
GetLdflagsR"RRtInvertRelativePathR>tAddImplicitPostbuildsRoR=R?R@R�R7tanyRtR�R�tGetLibtoolflagsRAtAdjustLibrariesR@R�tGetSpecPostbuildCommandsR�tGetSortedXcodePostbuildEnvR�tinserttxrangeRvt
startswithR^R�R�tGetFrameworkVersionR�R�R�R�R�R�(R�RwR�R�R�RR�R�ttarget_postbuildsR R!RDtgyp_to_buildttarget_postbuildREtlibrary_dirRFRLR�tlink_dept	file_descR�tinstallable_deps((R�sW/usr/lib/node_modules/npm/node_modules.bundled/node-gyp/gyp/pylib/gyp/generator/make.pyR��s0



		!		
	%	#		
	



	





			
$
RcCscd}|rEg|D]}|||�^q}ddj|�}n|jjd||f�dS(s�Write a variable definition that is a list of values.

    E.g. WriteList(['a','b'], 'foo', prefix='blah') writes out
         foo = blaha blahb
    but in a pretty-printed style.
    Rs \
	s	%s :=%s

N(R@R�RJ(R�t
value_listR�R
Rtvaluestl((sW/usr/lib/node_modules/npm/node_modules.bundled/node-gyp/gyp/pylib/gyp/generator/make.pyR�s
#c	Cs�d}|rd}n|j||dd||fgd|d|dt�g|D]}t|t�^qQ}|jdd	j|��d
S(s�Write a Makefile rule that uses do_cmd.

    This makes the outputs dependent on the command line that was run,
    as well as support the V= make command line flag.
    Rs,,1R�s$(call do_cmd,%s%s)RR�tforcesall_deps += %sRmN(R�R9RotSPACE_REPLACEMENTR�R@(	R�R�R�R�R�RRLtsuffixR�((sW/usr/lib/node_modules/npm/node_modules.bundled/node-gyp/gyp/pylib/gyp/generator/make.pyR��s	"c	Cs�tt|�}tt|�}|r8|jd|�n|r[|jddj|��n|ry|jd|d�n|r�dnd}	|r�|jddj|�dj|�|	f�n�t|�d	kr�|jd
|ddj|�|	f�n�d|r|n|j}
|jddj|�|
f�|jd�|jdd|
f�|jd
|
dj|�|	f�|jdd�|r�x"|D]}|jd
|�q�Wn|j�dS(s�Write a Makefile rule, with some extra tricks.

    outputs: a list of outputs for the rule (note: this is not directly
             supported by make; see comments below)
    inputs: a list of inputs for the rule
    actions: a list of shell commands to run for the rule
    comment: a comment to put in the Makefile above the rule (also useful
             for making this Python script's code self-documenting)
    order_only: if true, makes the dependency order-only
    force: if true, include FORCE_DO_CMD as an order-only dep
    phony: if true, the rule does not actually generate the named output, the
           output is just a name to run the rule
    command: (optional) command name to generate unambiguous labels
    s# s.PHONY: Rms%s: TOOLSET := $(TOOLSET)is
 FORCE_DO_CMDRs
%s: | %s%sis%s: %s%ss%s.intermediates%s: %ss	%ss@:s
.INTERMEDIATEs$(call do_cmd,touch)Ns	@:(R�RoR�R@RvR�Ra(R�R�R�R�RRRoRWR�tforce_appendtintermediateR�((sW/usr/lib/node_modules/npm/node_modules.bundled/node-gyp/gyp/pylib/gyp/generator/make.pyR��s2	&*
 
	
cCs|jdkrdS|jd�|jd�|jd|�|jd�|jd	�|jd
�|jd�idd
6dd6dd6}d}x`|D]X}tjj|�d}||kr�||cd7<||||kr�|}q�q�q�W|jd|�|jt|jtt	|��d�d�}idd6}	i}
t
|
|	�|j||td|
d�d�|j||tdtd�d�|jdkr�|jd�n>|jdkr�|jd�n|jdkr�|jd�n|j�dS( s�Write a set of LOCAL_XXX definitions for Android NDK.

    These variable definitions will be used by Android NDK but do nothing for
    non-Android applications.

    Arguments:
      module_name: Android NDK module name, which must be unique among all
          module names.
      all_sources: A list of source files (will be filtered by Compilable).
      link_deps: A list of link dependencies, which must be sorted in
          the order from dependencies to dependents.
    R�R�RqNs/# Variable definitions for Android applicationssinclude $(CLEAR_VARS)sLOCAL_MODULE := siLOCAL_CFLAGS := $(CFLAGS_$(BUILDTYPE)) $(DEFS_$(BUILDTYPE)) $(CFLAGS_C_$(BUILDTYPE)) $(INCS_$(BUILDTYPE))s+LOCAL_CPPFLAGS := $(CFLAGS_CC_$(BUILDTYPE))sLOCAL_C_INCLUDES :=s/LOCAL_LDLIBS := $(LDFLAGS_$(BUILDTYPE)) $(LIBS)is.ccs.cpps.cxxisLOCAL_CPP_EXTENSION := tLOCAL_SRC_FILEScSsog}xb|D]Z}tjj|�}|j|�r
|j|�r
|j|t|�t|�!�q
q
W|S(N(R=R>RsRcRQRtRv(R�R
RqtmodulestfilepathRT((sW/usr/lib/node_modules/npm/node_modules.bundled/node-gyp/gyp/pylib/gyp/generator/make.pyt
DepsToModuless
(RR+RRtLOCAL_SHARED_LIBRARIESRRtLOCAL_STATIC_LIBRARIESsinclude $(BUILD_EXECUTABLE)sinclude $(BUILD_SHARED_LIBRARY)sinclude $(BUILD_STATIC_LIBRARY)(s
executablesshared_librarysstatic_library(RpR�R=R>RYR�R�R�R�RWR.R"(R�tmodule_nameRxR�tcpp_exttdefault_cpp_extRTRMRwR*R)((sW/usr/lib/node_modules/npm/node_modules.bundled/node-gyp/gyp/pylib/gyp/generator/make.pyR��sR







		



cCs|jj|d�dS(Ns
(R�RJ(R�ttext((sW/usr/lib/node_modules/npm/node_modules.bundled/node-gyp/gyp/pylib/gyp/generator/make.pyR�3scCs1tjj|jdtjjd|j�d|�S(Ns$(abs_builddir)s
$(abs_srcdir)s$(BUILDTYPE)(RR�R�R�R=R>R@(R�R((sW/usr/lib/node_modules/npm/node_modules.bundled/node-gyp/gyp/pylib/gyp/generator/make.pyR�7s		cCs,|jjdd�}|jdi|d6�S(NtCHROMIUM_STRIP_SAVE_FILERR(R�tGetPerTargetSettingR�(R�tstrip_save_file((sW/usr/lib/node_modules/npm/node_modules.bundled/node-gyp/gyp/pylib/gyp/generator/make.pyR`>s		cCs;x4|D],\}}|jdt|�||f�qWdS(Ns%s: export %s := %s(R�Ro(R�R�R�tktv((sW/usr/lib/node_modules/npm/node_modules.bundled/node-gyp/gyp/pylib/gyp/generator/make.pyR�IscCsNd|kr(|jdd|j�}nd|krJd|j|f}n|S(s,Convert a path to its output directory form.s$(s$(obj)/s$(obj).%s/$(TARGET)/s$(obj)s$(obj).%s/$(TARGET)/%s(R\R�(R�R>((sW/usr/lib/node_modules/npm/node_modules.bundled/node-gyp/gyp/pylib/gyp/generator/make.pyRTs
cCsR|j|�}d|kr>|jdd|j|f�}|Sd|j||fS(s:Convert a prefix header path to its output directory form.s$(s$(obj)/s$(obj).%s/$(TARGET)/pch-%ss$(obj).%s/$(TARGET)/pch-%s/%s(R�R\R�(R�R>R0((sW/usr/lib/node_modules/npm/node_modules.bundled/node-gyp/gyp/pylib/gyp/generator/make.pyR�]scCs;d|kr|jd�Stjjtjj|j|��S(slConvert a subdirectory-relative path into a base-relative path.
    Skips over paths that contain variables.s$(t/(trstripR=R>R?R@(R�R>((sW/usr/lib/node_modules/npm/node_modules.bundled/node-gyp/gyp/pylib/gyp/generator/make.pyR�gs
cCs8d|krd|kr|S|i|d6|d6}|S(Ns%(INPUT_ROOT)ss%(INPUT_DIRNAME)st
INPUT_ROOTt
INPUT_DIRNAME((R�ttemplatet	expansionR�R>((sW/usr/lib/node_modules/npm/node_modules.bundled/node-gyp/gyp/pylib/gyp/generator/make.pyR�rscCsd|jS(sCReturns the location of the final output for an installable target.s$(builddir)/(R�(R�((sW/usr/lib/node_modules/npm/node_modules.bundled/node-gyp/gyp/pylib/gyp/generator/make.pyR�|sN(%t__name__t
__module__t__doc__R�R�R�R�R�R�R�R�R�RR;R<R�R�R�R�RCR�R8ReR�RUR�R�R�R�R�R`R�RR�R�R�R�(((sW/usr/lib/node_modules/npm/node_modules.bundled/node-gyp/gyp/pylib/gyp/generator/make.pyR��sF		�		d	�	&			|	!	(							�9	S					
		
cCs�|d}g|dD]}tjj||j�^q}tjj|d|j�}|jtj�stjj	d|�}n|j
di|d6dj	tt|��d6tjj
|d	gtj|�|�d
6�dS(s,Write the target to regenerate the Makefile.R1tbuild_files_argt
gyp_binaryR�s�quiet_cmd_regen_makefile = ACTION Regenerating $@
cmd_regen_makefile = cd $(srcdir); %(cmd)s
%(makefile_name)s: %(deps)s
	$(call do_cmd,regen_makefile)

t
makefile_nameRmR�s-fmaketcmdN(RRtRelativePathR<tFixIfRelativePathRcR=tsepR>R@RJR�RlR�tRegenerateFlags(R*t
root_makefileR�tbuild_filesR1RTtbuild_files_argsR�((sW/usr/lib/node_modules/npm/node_modules.bundled/node-gyp/gyp/pylib/gyp/generator/make.pytWriteAutoRegenerationRule�s
,	cCs�|d}xr|D]j}dg}|jrN|jdkrN|d|jf7}n|jd|�d||fGHtj|�qWdS(NR1tmakeR�s-Cs
BUILDTYPE=sBuilding [%s]: %s(R<Rtt
subprocesst
check_call(tdatatconfigurationsR*R1R!t	arguments((sW/usr/lib/node_modules/npm/node_modules.bundled/node-gyp/gyp/pylib/gyp/generator/make.pytPerformBuild�s

	c2
sC	|d�tjj|�}|jdi�}|jdd�}|jdd�}|jdd�}�fd�}	d}
tg|D]}||d	^q��}x6|D].}||}
|
d
dkr�|
d
}
Pq�q�W|
s�d}
nd}d
�j}tjj	�j
|�}�jr[tjj	�j
�j|�}tjj|�j�}da
nd}d}i	|d6|d6|
d
6|d6dd6td6dd6|d6|d6}|dkr�d}|ji|d6dd6td6td6�n�|dkr
|jitd6�n�|dkr7|jidd6dd6�n�|dkrZ|jid d6�ng|d!kr�d"}|ji|d6�n>|d#kr�d"}|ji|d6td6dd6dd6�n|jitd]d&�d'6td^d*�d+6td_d.�d/6td`d2�d36tdad5�d66tdbd8�d96tdcd;�d<6tddd>�d?6�tjj|d@�\}}}||jdAg�}i}x?|D]7\}}|jdB�r�dC|||tdB� <q�q�Wd}x�|D]�\}}tjdD|�r�q�n|d@dEkrdC|}n|j|�}|rHdF||f}||=n|dekr�|dG|7}|jddH�}|tjkr�tj|}n|dI||f7}|dJ7}q�|dK||f7}q�W||dA<tjj|�t|dL�}|jt|�|r|jdM�nx)|D]!}|jdN|�t |�q#Wtjj!|�}tjj"||�t�} xB|dOD]6}x-tjj#|||�D]}| j$|�q�Wq�Wt�}!t�}"x�|D]�}#tjj|#�\}}}||jdAg�}$|!j$tjj|�j
��||dP}%x�|%D]y}&tjjtjj%|&|��j
�}'tjj&|'�}(|dQr�|(j'|dQ�r�|!j$|(�q?|!j$|'�q?W|	||d|�jdR�\})}*||#}
|
dS}+|dkrtj(j)|||
�nt*||�},|,j+|#|)|*|
|+dT|#| k�tjj|*tjj!|��}-|"j$|-�q�Wtjj�j,tj-��}.x�|!D]�}tjj	|.|�}g|D]/}|j'|�r�|| kr�||dU^q�}/|/sq�n|	|tjj.tjj/|��d@dV�\})}*tjjtjj!|�tjj!|*��}0|,j0|*|0|/|�q�W|jdW�xKt1|"�D]=}1|jdX|1dY�|jdZ|1dW�|jdJ�q�W|jdW�|jd[�r(	|jd\t2�r(	t3||||!�n|jt4�|j5�dS(fNR1R/R2R3R0tdefault_targetRXcs�tjjtjj|��j�}tjj�j||�}�jrltjj�j�j||�}ntjjtjj|��j	�}||fS(s9Determine where to write a Makefile for a given gyp file.(
RRR�R=R>R�tdepthR@R;R<(t
build_filet	base_nameR�toutput_file(R1(sW/usr/lib/node_modules/npm/node_modules.bundled/node-gyp/gyp/pylib/gyp/generator/make.pytCalculateMakefilePath�s		R�tdefault_configurationtDefaultR�tMakefiles
$(srcdir)/tflocks-aftbuilddiritflock_indext
link_commandsRtextra_commandstsrcdirtcopy_archive_argsRs./gyp-mac-tool flockiRtsolariss./gyp-flock-tool flocktfreebsdtlockfRNs-pPRftaixt	CC_targettCCs$(CC)s	CC.targett	AR_targettARs$(AR)s	AR.targett
CXX_targettCXXs$(CXX)s
CXX.targettLINK_targettLINKs$(LINK)sLINK.targettCC_hosttgccsCC.hosttAR_hosttarsAR.hosttCXX_hostsg++sCXX.hostt	LINK_hosts$(CXX.host)s	LINK.hostitmake_global_settingst_wrappers
$(abspath %s)s
.*_wrapperR_s%s %ss3ifneq (,$(filter $(origin %s), undefined default))
Rfs
  %s = %s
sendif
s	%s ?= %s
R�sU# Define LOCAL_PATH for build of Android applications.
LOCAL_PATH := $(call my-dir)

sTOOLSET := %s
R�tincluded_filesthome_dot_gyps.mkR�R�Rrs	.Makefiles
smifeq ($(strip $(foreach prefix,$(NO_LOAD),\
    $(findstring $(join ^,$(prefix)),\
                 $(join ^,s)))),)
s
  include t
standalonetauto_regeneration(R�sCC(R�sAR(R�sCXX(R�R�(R�sCC(R�sAR(R�sCXX(R�R�(sCCsCC.hostsCXXsCXX.host(6RRR R7R8R�RqR=R>R@R<R;R�RktLINK_COMMANDS_LINUXR(tLINK_COMMANDS_MACtSHARED_HEADER_MAC_COMMANDStLINK_COMMANDS_ANDROIDtLINK_COMMANDS_AIXRtParseQualifiedTargetRQRvRgtmatchR\tenvironR�R�RJt
SHARED_HEADERRNR�tCopyToolt
AllTargetsR�tUnrelativePathtabspathRcR�tMergeGlobalXcodeSettingsToSpecR�R�R�tgetcwdRYRsR�RFR9R�t
SHARED_FOOTERR�(2ttarget_listttarget_dictsR�R*R+R/RBR0R�R�R�R�ttoolsetsRwR�R�R�t
flock_commandtcopy_archive_argumentst
header_paramsR�Rftmake_global_settings_arraytwrappersREtvalueR�twrappertenv_keyR�R�t	dest_pathtneeded_targetsR�tinclude_listR�tthis_make_global_settingsR�t
included_filetrelative_include_filetabs_include_fileR�R�R�RKtmkfile_rel_pathtdepth_rel_pathtgyp_targetstmakefile_rel_pathtinclude_file((R1sW/usr/lib/node_modules/npm/node_modules.bundled/node-gyp/gyp/pylib/gyp/generator/make.pytGenerateOutput�sR
'


	
			
							 





			
	
	
"




 /


(5R=RgtsysR�Rt
gyp.commontgyp.xcode_emulationRRR"R9t$generator_supports_multiple_toolsetsRUR:RRRR8RAR.RCRpR�R�R�R�R�R�RNR�R�R�R�R'RWRXRZR^R`RbReRiRkRlRoRR�R�tobjectR�R�R�R�(((sW/usr/lib/node_modules/npm/node_modules.bundled/node-gyp/gyp/pylib/gyp/generator/make.pyt<module>s�
	"	!%�'"	
												 �����	

Zerion Mini Shell 1.0