�
��Zc�����������@���s���d��d�l��m�Z�d��d�l��m�Z�d��d�l��m�Z�d��d�l��m�Z�d��d�l��m�Z�d��d�l��m�Z�d��d�l��m�Z�d��d�l�Z�d��d�l	�Z	�d��d�l
�Z�d��d�l�Z�d��d�l
�Z
�d��d�l�Z�d��d�l�Z�d��d�l�Z�d��d�l�Z�d��d�l�Z�d��d�l�Z�d��d�l�Z�d��d�l�Z�d��d�l�Z�d��d	�l
�m�Z�d
�d�d�g�Z�d
�d�g�Z�d�d�d�d�d�d�d�g�Z�g��a�e�d���Z�e�j�d���Z �d����Z!�d�d�d�d�d
�d�d�d�d�d �d!�d"�d#�d$�d�d%�d&�d'�d(�d)�d*�d+�g�Z"�g��a#�d�d,�d�d
�d-�d�d.�d�d%�d'�d*�g�Z$�e%�a&�e'�a(�e'�d/���Z)�d0����Z*�d1����Z+�d2����Z,�d3����Z-�d4����Z.�d5����Z/�d6����Z0�d7����Z1�d8�e2�f�d9�������YZ3�d:�e4�f�d;�������YZ5�d<����Z6�e�d=���Z7�i�d>�d?�6d@�dA�6dB�dC�6Z8�dD����Z9�e�j�dE���Z:�dF����Z;�e�j�dG���Z<�e�j�dH���Z=�e�j�dI���Z>�i��Z?�dJ����Z@�dK�ZA�dL�ZB�dM�ZC�dN����ZD�dO����ZE�dP����ZF�dQ����ZG�e'�dR���ZH�dS����ZI�dT����ZJ�dU����ZK�dV����ZL�dW����ZM�dX����ZN�dY����ZO�dZ����ZP�d[�e4�f�d\�������YZQ�d]����ZR�d^����ZS�d_����ZT�d`����ZU�e�j�da���ZV�db����ZW�e%�eX�dc���ZY�dd����ZZ�de����Z[�df����Z\�dg����Z]�dh����Z^�di����Z_�dj����Z`�dk����Za�dl����Zb�dm����Zc�dn����Zd�do����Ze�dp����Zf�dq����Zg�dr����Zh�ds����Zi�d�S(t���i����(���t���Const(���t���Dict(���t���Discard(���t���List(���t���Module(���t���Node(���t���StmtN(���t���GypErrort
���executablet���shared_libraryt���loadable_modulet���dependenciest���export_dependent_settingst���destinationt���filest���include_dirst���inputst	���librariest���outputst���sourcess���=+?!s���_(dir|file|path)s?$c���������C���s:���x�|��d�t��k�r �|��d� }��q�W|��t�k�p9�t�j�|����S(���Ni����(���t���is_path_section_charsett
���path_sectionst���is_path_section_match_ret���search(���t���section(����(����s ���externals/gyp/pylib/gyp/input.pyt
���IsPathSection5���s����t���actionst���configurationst���copiest���default_configurationt���dependencies_originalt
���postbuildst���product_dirt���product_extensiont���product_namet���product_prefixt���rulest���run_ast���standalone_static_libraryt���suppress_wildcardt���target_namet���toolsett���toolsetst���typet	���variablest���all_dependent_settingst���direct_dependent_settingst
���link_settingsc���������C���sg���|�d�k�r�g��}�n��|��|�k�r%�|�S|�j�|����x.�|�|��j�d�g����D]�}�t�|�|�|���qI�W|�S(���s��Return a list of all build files included into build_file_path.

  The returned list will contain build_file_path as well as all other files
  that it included, either directly or indirectly.  Note that the list may
  contain files that were included into a conditional section that evaluated
  to false and was not merged into build_file_path's dict.

  aux_data is a dict containing a key for each build file or included build
  file.  Those keys provide access to dicts whose "included" keys contain
  lists of all other files included by the build file.

  included should be left at its default None value by external callers.  It
  is used for recursion.

  The returned list will not contain any duplicate entries.  Each build file
  in the list will be relative to the current directory.
  t���includedN(���t���Nonet���appendt���gett���GetIncludedBuildFiles(���t���build_file_patht���aux_dataR0���t���included_build_file(����(����s ���externals/gyp/pylib/gyp/input.pyR4���w���s����	
c���������C���s����t��j�|����}�t�|�t���s$�t���|�j����}�|�d�d�k�sF�t���t�|�d�t���s_�t���|�d�j����}�t�|�d�t���s��t���|�d�j����}�t	�|���d�k�s��t���t
�|�d�g����S(���s����Return the eval of a gyp file.

  The gyp file is restricted to dictionaries and lists only, and
  repeated keys are not allowed.

  Note that this is slower than eval() is.
  i����i���N(���t���compilert���parset
���isinstanceR���t���AssertionErrort���getChildrenR1���R���R���t���lent	���CheckNode(���t
���file_contentst���astt���c1t���c2t���c3(����(����s ���externals/gyp/pylib/gyp/input.pyt���CheckedEval����s����	c���
������C���s���t��|��t���r��|��j����}�i��}�x��t�d�t�|���d���D]��}�t��|�|�t���sY�t���|�|�j����d�}�|�|�k�r��t�d�|�d�t�t�|���d���d�d�j	�|���d�����n��t
�|���}�|�j�|���t�|�|�d�|���|�|�<q:�W|�St��|��t
���rl|��j����}�g��}�xO�t�|���D]A�\�}�}	�t
�|���}�|�j�t�|�����|�j�t�|	�|�����q#W|�St��|��t���r�|��j����d�St�d	�d�j	�|���d
�t�|������d��S(���Ni����i���s���Key 's���' repeated at level i���s��� with key path 't���.t���'s���Unknown AST node at key path 's���': (���R:���R���R<���t���rangeR=���R����R;���R���t���reprt���joint���listR2���R>���R���t	���enumeratet	���TypeError(
���t���nodet���keypatht���ct���dictt���nt���keyt���kpt���childrent���indext���child(����(����s ���externals/gyp/pylib/gyp/input.pyR>�������s2����=
c���
������C���s���|��|�k�r�|�|��St��j�j�|����r;�t�|����j����}�n�t�d�|��t��j����f�����d��}�y2�|�ru�t�|���}�n�t	�|�i�d��d�6d����}�WnK�t
�k
�r��}	�|��|	�_����n-�t�k
�r��}	�t
�j�j�|	�d�|�������n�Xt�|�t���s��t�d�|������n��|�|�|��<i��|�|��<d�|�k�s*|�d�r�yE�|�rRt�|�|��|�|�|�|�|���n�t�|�|��|�|�|�d��|���Wq�t�k
�r�}	�t
�j�j�|	�d�|�������q�Xn��|�S(���Ns���%s not found (cwd: %s)t���__builtins__s���while reading s%���%s does not evaluate to a dictionary.t
���skip_includess���while reading includes of (���t���ost���patht���existst���opent���readR���t���getcwdR1���RD���t���evalt���SyntaxErrort���filenamet	���Exceptiont���gypt���commont���ExceptionAppendR:���RP���t���LoadBuildFileIncludesIntoDict(
���R5���t���dataR6���R,���t���includest	���is_targett���checkt���build_file_contentst���build_file_datat���e(����(����s ���externals/gyp/pylib/gyp/input.pyt���LoadOneBuildFile����sD����
	


c���������C���s���g��}�|�d��k�r"�|�j�|���n��d�|��k�r��xL�|��d�D]@�}�t�j�j�t�j�j�t�j�j�|���|�����}	�|�j�|	���q9�W|��d�=n��x��|�D]}�}�d�|�|�k�r��g��|�|�d�<n��|�|�d�j�|���t�j	�t�j
�d�|���t�|��t�|�|�|�|�d��t
�|���|�|���q��Wxs�|��j����D]e�\�}
�}�|�j�t�k�rVt�|�|�|�|�|�d��|���q|�j�t�k�rt�|�|�|�|�|�|���qqWd��S(���NRh���R0���s���Loading Included File: '%s'(���R1���t���extendRY���RZ���t���normpathRI���t���dirnameR2���Rc���t���DebugOutputt���DEBUG_INCLUDESt
���MergeDictsRn���t���Falset	���iteritemst	���__class__RP���Rf���RJ���t���LoadBuildFileIncludesIntoList(���t���subdictt���subdict_pathRg���R6���R,���Rh���Rj���t
���includes_listt���includet���relative_includet���kt���v(����(����s ���externals/gyp/pylib/gyp/input.pyRf�������s0����-

	
c������	���C���sn���xg�|��D]_�}�|�j��t�k�r;�t�|�|�|�|�|�d��|���q�|�j��t�k�r�t�|�|�|�|�|�|���q�q�Wd��S(���N(���Rw���RP���Rf���R1���RJ���Rx���(���t���sublistt���sublist_pathRg���R6���R,���Rj���t���item(����(����s ���externals/gyp/pylib/gyp/input.pyRx���#��s����
c���	������C���sf��d�|��k�r
|��d�}�g��}�x��|�D]��}�d�|�k�rT�d�|�k�rT�|�j��|���q#�n��t�rr�|�j�d�d�g���}�n	�d�g�}�d�|�k�r��|�d�=n��t�|���d�k�r#�x8�|�d�D],�}�t�j�|���}�|�|�d�<|�j��|���q��W|�d�|�d�<|�j��|���q#�q#�W|�|��d�<n��d�|��k�rbxF�|��d�D]7�}�t�|�t���r$x�|�d�D]�}�t�|���qDWq$q$Wn��d��S(���Nt���targetsR)���R*���t���targeti����i���t
���conditions(	���R2���t���multiple_toolsetsR3���R=���t���copyt���deepcopyR:���RJ���t���ProcessToolsetsInDict(	���Rg���t���target_listt���new_target_listR����R*���t���buildt
���new_targett	���conditiont���condition_dict(����(����s ���externals/gyp/pylib/gyp/input.pyR����/��s2����


	


c������
���C���s���|�rY�t��j�j�|�t�j�j�|������}�|�d�k�r@�d�|�d�<qY�|�j�d�d���|�d�<n��|��|�d�k�rm�t�S|�d�j�|����t��j	�t��j
�d�|����t�|��|�|�|�|�t�|���}	�|�|	�d�<d	�|	�k�r��t
�|��d
�����n��t�|��|���}
�g��|	�d	�<x@�|
�D]8�}�t��j�j�|�t�j�j�|������}�|	�d	�j�|���q��Wt�|	���t�|	�t�|�|����t�|	���d�|	�k�rd�|	�k�r�t
�d
�|������n��d�}
�xf�|
�t�|	�d���k��r�|	�d�|
�}�t�j�|	�d���}�t�|�|�|��|����|�|	�d�|
�<|
�d�7}
�q�W|	�d�=n��g��}�d�|	�k�rvx_�|	�d�D]P�}�d�|�k�r7qn��x5�|�d�D])�}�|�j�t��j�j�|��|�d����d���qBWqWn��|�r�xn�|�D]Y�}�y#�t�|�|�|�|�|�|�|�|���Wq�t�k
�r�}�t��j�j�|�d�|�������q�Xq�Wn
�|��|�f�Sd��S(���Nt����RE���t���DEPTHs���\t���/t���target_build_filess���Loading Target Build File '%s't���_DEPTHt���included_filess$��� must not contain included_files keyt���target_defaultsR����s'���Unable to find targets in build file %si����i���R���s ���while loading dependencies of %s(���Rc���Rd���t���RelativePathRY���RZ���Rq���t���replaceRu���t���addRr���Rs���Rn���t���TrueR���R4���R2���R����t#���ProcessVariablesAndConditionsInDictt���PHASE_EARLYR=���R����R����Rt���t
���ResolveTargetR1���t���LoadTargetBuildFileRb���Re���(���R5���Rg���R6���R,���Rh���t���depthRj���t���load_dependenciest���dRl���R0���t
���included_filet���included_relativeRU���t���old_target_dictt���new_target_dictR���t���target_dictt
���dependencyRm���(����(����s ���externals/gyp/pylib/gyp/input.pyR����S��sp����!







	

(
	c	������	���C���s���y't��j��t��j�t��j���x'�|��j����D]�\�}	�}
�|
�t����|	�<q&�Wt�|���}�t�|���}�t�|���t�|�|�|�|�|�|�|�t���}
�|
�s��|
�S|
�\�}�}�i��}�x=�|�D]5�}	�|	�d�k�r��q��n��|	�|�k�r��|�|	�|�|	�<q��q��Wi��}�x+�|�D]#�}	�|	�|�k�r��|�|	�|�|	�<q��q��W|�|�|�|�f�SWna�t	�k
�rQ}�t
�j�j�d�|���d�St�k
�r�}�t
�j�d�I|�IJt
�j�t�j����IJd�SXd�S(���s����Wrapper around LoadTargetBuildFile for parallel processing.

     This wrapper is used when LoadTargetBuildFile is executed in
     a worker process.
  R����s���gyp: %s
s
���Exception:N(���t���signalt���SIGINTt���SIG_IGNRv���t���globalst���sett���SetGeneratorGlobalsR����Ru���R���t���syst���stderrt���writeR1���Rb���t	���tracebackt
���format_exc(���t���global_flagsR5���Rg���R6���R,���Rh���R����Rj���t���generator_input_infoRR���t���valuet	���data_keyst
���aux_data_keyst���resultR���t���data_outt���aux_data_outRm���(����(����s ���externals/gyp/pylib/gyp/input.pyt���CallLoadTargetBuildFile���sD����
	

t���ParallelProcessingErrorc�����������B���s���e��Z�RS(����(���t���__name__t
���__module__(����(����(����s ���externals/gyp/pylib/gyp/input.pyR�������s���t
���ParallelStatec�����������B���s ���e��Z�d��Z�d����Z�d����Z�RS(���s��Class to keep track of state when processing input files in parallel.

  If build files are loaded in parallel, use this to keep track of
  state during farming out and processing parallel jobs. It's stored
  in a global so that the callback function can have access to it.
  c���������C���sO���d��|��_�d��|��_�d��|��_�d��|��_�d�|��_�t����|��_�g��|��_�t	�|��_
�d��S(���Ni����(���R1���t���poolR����Rg���R6���t���pendingR����t	���scheduledR���Ru���t���error(���t���self(����(����s ���externals/gyp/pylib/gyp/input.pyt���__init__��s����						c���������C���s��|��j��j����|�s:�t�|��_�|��j��j����|��j��j����d�S|�\�}�}�}�}�|��j�d�j�|���x�|�D]�}�|�|�|��j�|�<qg�Wx�|�D]�}�|�|�|��j�|�<q��Wx@�|�D]8�}�|�|��j	�k�r��|��j	�j�|���|��j
�j�|���q��q��W|��j�d�8_�|��j��j����|��j��j����d�S(���sJ���Handle the results of running LoadTargetBuildFile in another process.
    NR����i���(
���R����t���acquireR����R����t���notifyt���releaseRg���R����R6���R����R���R2���R����(���R����R����t���build_file_path0t���data0t	���aux_data0t
���dependencies0RR���t���new_dependency(����(����s ���externals/gyp/pylib/gyp/input.pyt���LoadTargetBuildFileCallback��s&����
	





(���R����R����t���__doc__R����R����(����(����(����s ���externals/gyp/pylib/gyp/input.pyR�������s���	c���������C���s���t�����}�t�j����|�_�t�|����|�_�t�|����|�_�d�|�_�|�|�_	�|�|�_
�y|�j�j����x��|�j�sv�|�j�rb|�j�r��Pn��|�j�s��|�j�j
����qd�n��|�j�j����}	�|�j�d�7_�i��}
�|�d�|
�d�<i��}�i�t����d�d�6t����d�d�6t����d�d�6}�|�j�s%t�j�d���|�_�n��|�j�j�t�d�|�|	�|
�|�|�|�|�|�|�f	�d	�|�j��qd�WWn&�t�k
�r�}
�|�j�j����|
���n�X|�j�j����|�j�j����|�j�j����d��|�_�|�j�r�t�j�d���n��d��S(
���Ni����i���R����R���t���non_configuration_keysR����i���t���argst���callback(���R����t	���threadingt	���ConditionR����RJ���R���R����R����R����Rg���R6���R����R����t���waitt���popR����R����t���multiprocessingt���Poolt���apply_asyncR����R����t���KeyboardInterruptt	���terminateR����t���closeRI���R1���R����t���exit(���t���build_filesRg���R6���R,���Rh���R����Rj���R����t���parallel_stateR����t���data_int���aux_data_inR����Rm���(����(����s ���externals/gyp/pylib/gyp/input.pyt���LoadTargetBuildFilesParallel1��sR����				
		
		




		s���{[(t���{t���}t���[t���]t���(t���)c���������C���s����g��}�d�}�x��t��|����D]��\�}�}�|�t�k�rV�|�j�|���|�d�k�r��|�}�q��q�|�t�k�r�|�sl�d�S|�j����t�|�k�r��d�S|�s��|�|�d�f�Sq�q�Wd�S(���Ni����i���(���i����i����(���i����i����(���i����i����(���RK���t	���LBRACKETSR2���t���BRACKETSR����(���t	���input_strt���stackt���startRU���t���char(����(����s ���externals/gyp/pylib/gyp/input.pyt���FindEnclosingBracketGroupm��s����
s���(0|-?[1-9][0-9]*)$c���������C���s���t��|��t���o�t�j�|����S(���s|���Returns True if |string| is in its canonical integer form.

  The canonical form is such that str(int(string)) == string.
  (���R:���t���strt���canonical_int_ret���match(���t���string(����(����s ���externals/gyp/pylib/gyp/input.pyt���IsStrCanonicalInt���s����sy���(?P<replace>(?P<type><(?:(?:!?@?)|\|)?)(?P<command_string>[-a-zA-Z0-9_.]+)?\((?P<is_array>\s*\[?)(?P<content>.*?)(\]?)\))sy���(?P<replace>(?P<type>>(?:(?:!?@?)|\|)?)(?P<command_string>[-a-zA-Z0-9_.]+)?\((?P<is_array>\s*\[?)(?P<content>.*?)(\]?)\))s|���(?P<replace>(?P<type>[\^](?:(?:!?@?)|\|)?)(?P<command_string>[-a-zA-Z0-9_.]+)?\((?P<is_array>\s*\[?)(?P<content>.*?)(\]?)\))c���������C���sd���t��j�d�k�r`�t�|����t�k�rH�t�j�d�d�|��d���g�|��d�}��q`�t�j�d�d�|����}��n��|��S(���Nt���win32s���^cat s���type i����i���(���R����t���platformR+���RJ���t���ret���sub(���t���cmd(����(����s ���externals/gyp/pylib/gyp/input.pyt���FixupPlatformCommand���s
����'i����i���i���c���.���
���C���sc��|�t��k�r�t�}�d�}�nB�|�t�k�r6�t�}�d�}�n'�|�t�k�rQ�t�}�d�}�n�t�s]�t���t�|����}�t	�|���r�t
�|���S|�|�k�r��|�St�|�j�|�����}�|�s��|�S|�}�|�j
����x�|�D]�}	�|	�j����}
�t�j�t�j�d�|
���d�|
�d�k�}�|
�d�}�d�|
�d�k�}
�|	�j�d	���}�|	�j�d	���}�t�|�|���\�}�}�|�|�}�|�|�|�!}�|�|�d
�}�|�d
�}�|�|�|�!}�|
�r�t�j�|���}�t�|�|���t�|�|�|�|���}�n�t�|�|�|�|���}�|�j����}�d�|
�d�k�o�|�|�k�}�|�s
|
�r;t�j�j�|���}�|�d�k�r;|
�r;d��}�q;n��|
�r~t�|���t�k�r\|�}�n�|�j�d
���}�|�d�}�t�j�j �|���r�t!�d�|�����n��t"�s�t�j�j#�|�|���}�nl�t�j�j �|���r�t"�d�}�t�j$�j%�|�|���}�n�|�}�t"�d�}�t�j�j#�|�|�|���}�t�j$�j&�|���t�j$�j%�|�|���}�t�j$�j'�|���}�x#�|�d
�D]�}�|�j(�d�|���qVW|�j)����n}|�r�t*�} �|
�d�r�t+�|���}�t�} �n��t�|���}!�t,�j-�|!�d����}"�|"�d��k�r�t�j�t�j�d�|�|���d�}�|�d�k�r�t�j.����}#�|�r t�j/�|���n��zv�t0�j�|���}$�y�t1�|$�d���}%�Wn-�t2�k
�ru}&�t!�d�|$�d�|&�f�����n�Xt�|%�j3�|$�d
�����j4����}�Wd��t�j/�|#���X|�d��k�s�t���n��|�r�t!�d�|�|�f�����n��t5�|���}�t6�j7�|�d�| �d�t6�j8�d�t6�j8�d�t6�j8�d�|��}'�|'�j9�d���\�}(�})�|'�j:����d�k�sJ|)�rvt;�j<�j(�|)���t!�d�|�|'�j=�f�����n��|(�j4����}�|�t,�|!�<q�t�j�t�j�d�|�|���|"�}�nJ�|�|�k�r�|�d�d(�k�r�g��}�q�t!�d!�|�d"�|�����n
�|�|�}�t>�|�t���r�xd�|�D]\�}*�|�d�d �k�rt>�|*�t���rt>�|*�t
���rt!�d#�|�d$�d%�|*�j?�j@�����qqWtA�|�|�|�|���nE�t>�|�t���r�t>�|�t
���r�t!�d#�|�d$�d&�|�j?�j@�����n��|�rt>�|�t���r�|�}�qOt0�j�t�|�����}�nL�d�}+�t>�|�t���r-t�j$�jB�|���}+�n�|�}+�|�|� t�|+���|�|�}�|�}�q��Wt�j�t�j�d'�|���t>�|�t���r�|�r�t>�|�d�t���r�q�g��},�x*�|�D]"�}*�|,�jC�t�|*�|�|�|�����q�W|,�}�n�t�|�|�|�|���}�t>�|�t���rDxb�tD�d�tE�|�����D]-�}-�t	�|�|-���rt
�|�|-���|�|-�<qqWn�t	�|���r_t
�|���}�n��|�S()���Nt���<t���>t���^s���Matches: %rt���!R+���t���command_stringt���|R����i���t���@R����t��� i����s(���| cannot handle absolute paths, got "%s"t���toplevelt���qualified_out_dirs���%s
t���is_arrays(���Executing command '%s' in directory '%s't
���pymod_do_mains,���Error importing pymod_do_mainmodule (%s): %ss$���Unknown command string '%s' in '%s'.t���shellt���stdoutR����t���stdint���cwds%���Call to '%s' returned exit status %d.s2���Had cache value for command '%s' in directory '%s'i����R����s���Undefined variable s��� in s	���Variable s-��� must expand to a string or list of strings; s���list contains a s���found a s���Found output %r, recursing.(���R����R����(F���R����t���early_variable_ret
���PHASE_LATEt���late_variable_ret���PHASE_LATELATEt���latelate_variable_reRu���R;���R����R����t���intRJ���t���finditert���reverset	���groupdictRc���Rr���t���DEBUG_VARIABLESR����t���endR����R����R����t���ProcessListFiltersInDictt���ExpandVariablest���stripRY���RZ���Rq���R1���R+���t���splitt���isabsR���t���generator_filelist_pathsRI���Rd���R����t���EnsureDirExistst���WriteOnDiffR����R����R����R_���t���cached_command_resultsR3���R^���t���chdirt���shlext
���__import__t���ImportErrort���DoMaint���rstripR����t
���subprocesst���Popent���PIPEt���communicateR����R����R����t
���returncodeR:���Rw���R����t#���ProcessVariablesAndConditionsInListt���EncodePOSIXShellListR2���t���xrangeR=���(.���t���inputt���phaseR,���t
���build_filet���variable_ret���expansion_symbolR����t���matchest���outputt���match_groupR����t���run_commandR����t	���file_listt
���replace_startt���replace_endt���c_startt���c_endt���replacementt���contents_startt���contents_endt���contentst���processed_variablest���expand_to_listt���build_file_dirt
���contents_listRZ���R��t���rel_build_file_dirR��t���ft���it	���use_shellt	���cache_keyt���cached_valuet���oldwdt���parsed_contentst	���py_moduleRm���t���pt���p_stdoutt���p_stderrR����t���encoded_replacementt
���new_outputRU���(����(����s ���externals/gyp/pylib/gyp/input.pyR�����s@���			


	





		




	

#				

	
	

 
"
	

	c���������C���s���|�t��k�r�d�}�n1�|�t�k�r*�d�}�n�|�t�k�r:�d��St�sF�t���|�|��k�rV�d��S|��|�}�|��|�=x|�D]}�t�|�t���s��t�|�d�����n��t�|���d�k�r��t�|���d�k�r��t�|�d�|�d�d�t	�t�|���������n��|�d�d�!\�}�}�d��}	�t�|���d�k�r!|�d�}	�n��t�|�|�|�|���}
�t�|
�t	���rpt�|
�t���rpt
�d	�d
�t�j�j���n��y>�t�|
�d�d���}�t�|�i�d��d
�6|���r�|�}�n�|	�}�Wn��t�k
�r}
�t�d�t	�|
�j�d���|
�j�|�|
�j�f�|
�j�|
�j�|
�j�|
�j���}�|���n<�t�k
�rK}
�t�j�j�|
�d�|
�|�f���t�|
�����n�X|�d��k�rn�t�|�|�|�|���t�|��|�|�|���qn�qn�Wd��S(���NR����t���target_conditionss��� must be a listi���i���R��i����s��� must be length 2 or 3, not s7���Variable expansion in this context permits str and int s���only, found s���<string>R_���RW���s9���%s while evaluating condition '%s' in %s at character %d.s%���while evaluating condition '%s' in %s(���R����R��R��Ru���R;���R:���RJ���R���R=���R����R1���R��R��t
���ValueErrort���expandedRw���R����t���compileR_���R`���R����t���textt���offsetRa���t���linenot	���NameErrorRc���Rd���Re���R����Rt���(���t���the_dictR.��R,���R/��t���conditions_keyt���conditions_listR����t	���cond_exprt	���true_dictt
���false_dictt���cond_expr_expandedt���ast_codet
���merge_dictRm���t���syntax_error(����(����s ���externals/gyp/pylib/gyp/input.pyt���ProcessConditionsInDict���sZ����		

$,
		
#		
c���������C���s_���xX�|�j�����D]J�\�}�}�t�|�t���sF�t�|�t���sF�t�|�t���r
�|�|��d�|�<q
�q
�Wd��S(���Nt���_(���Rv���R:���R����R��RJ���(���R,���RY��RR���R����(����(����s ���externals/gyp/pylib/gyp/input.pyt���LoadAutomaticVariablesFromDictE��s����c���������C���s����x��|�j��d�i����j����D]��\�}�}�t�|�t���r[�t�|�t���r[�t�|�t���r[�q�n��|�j�d���r��|�d� }�|�|��k�r��q�n��|�d�k�r��|�|�k�r��|�|�}�q��n�|�}�|�|��|�<q�Wd��S(���NR,���t���%i����(���R3���Rv���R:���R����R��RJ���t���endswith(���R,���RY��t���the_dict_keyRR���R����t
���variable_name(����(����s ���externals/gyp/pylib/gyp/input.pyt���LoadVariablesFromVariablesDictN��s����% 
c���	������C���s:��|�j�����}�t�|�|����d�|��k�rm�x(�|��d�j����D]�\�}�}�|�|�|�<q6�Wt�|��d�|�|�|�d���n��t�|�|��|���x��|��j����D]��\�}�}�|�d�k�r��t�|�t���r��t�|�|�|�|���}�t�|�t���rt�|�t���rt	�d�d�|�j
�j�d�|���n��|�|��|�<q��q��W|�j�����}�t�|�|����t�|�|��|���t�|��|�|�|���|�j�����}�t�|�|����t�|�|��|���x��|��j����D]��\�}�}�|�d�k�s�t�|�t���r�q�n��t�|�t
���r�t�|�|�|�|�|���q�t�|�t���rt�|�|�|�|���q�t�|�t���s�t�d�|�j
�j�d�|���q�q�Wd�S(���s����Handle all variable and command expansion and conditional evaluation.

  This function is the public entry point for all variable expansions and
  conditional evaluations.  The variables_in dictionary will not be modified
  by this function.
  R,���s7���Variable expansion in this context permits str and int s���only, found s��� for s
���Unknown type N(���R����Re��Rv���R����Rj��R:���R����R��R��RR��Rw���R����Rc��RP���RJ���R*��RL���(	���RY��R.��t���variables_inR/��Rh��R,���RR���R����RS��(����(����s ���externals/gyp/pylib/gyp/input.pyR����k��sD����

 
"


c���������C���sU��d�}�xH|�t��|����k��rP|��|�}�t�|�t���rJ�t�|�|�|�|���n��t�|�t���ro�t�|�|�|�|���n��t�|�t���rt�|�|�|�|���}�t�|�t���s��t�|�t���r��|�|��|�<qCt�|�t���r��|�|��|�|�d�+|�t��|���7}�q	�qCt	�d�d�|�j
�j�d�|���n-�t�|�t���sCt�d�|�j
�j�d�|���n��|�d�}�q	�Wd��S(���Ni����i���s7���Variable expansion in this context permits strings and s���lists only, found s��� at s
���Unknown type s
��� at index (
���R=���R:���RP���R����RJ���R*��R����R��R��RR��Rw���R����RL���(���t���the_listR.��R,���R/��RU���R����RS��(����(����s ���externals/gyp/pylib/gyp/input.pyR*�����s,����


c���������C���s����i��}�x|�|��d�D]p�}�xg�|��|�j��d�g����D]O�}�t�j�j�|�|�d�|�d���}�|�|�k�rs�t�d�|�����n��|�|�|�<q.�Wq�W|�S(���sy��Builds a dict mapping fully-qualified target names to their target dicts.

  |data| is a dict mapping loaded build files by pathname relative to the
  current directory.  Values in |data| are build file contents.  For each
  |data| value with a "targets" key, the value of the "targets" key is taken
  as a list containing target dicts.  Each target's fully-qualified name is
  constructed from the pathname of the build file (|data| key) and its
  "target_name" property.  These fully-qualified names are used as the keys
  in the returned dict.  These keys provide access to the target dicts,
  the dicts in the "targets" lists.
  R����R����R(���R)���s!���Duplicate target definitions for (���R3���Rc���Rd���t���QualifiedTargetR���(���Rg���R����R/��R����R(���(����(����s ���externals/gyp/pylib/gyp/input.pyt���BuildTargetsDict���s����

c���������C���sC��g��t��D]�}�d�D]�}�|�|�^�q�q�}�x|��j����D]\�}�}�t�j�j�|���}�|�d�}�x��|�D]��}�|�j�|�g����}	�x��t�d�t�|	�����D]��}
�t�j�j�|�|	�|
�|���\�}�}�}
�t	�s��|�}
�n��t�j�j
�|�|�|
���}�|�|	�|
�<|�d�k�r��|�|�d�k�r��t�d�|�d�|�d	�|�d
�����q��q��Wqf�Wq7�Wd�S(
���s���Make dependency links fully-qualified relative to the current directory.

  |targets| is a dict mapping fully-qualified target names to their target
  dicts.  For each target in this dict, keys known to contain dependency
  links are examined, and any dependencies referenced will be rewritten
  so that they are fully-qualified and relative to the current directory.
  All rewritten dependencies are suitable for use as keys to |targets| or a
  similar dict.
  R����R����R����R)���i����R���s���Found s��� in s��� of s���, but not in dependenciesN(���R����R����R����(���t���dependency_sectionsRv���Rc���Rd���t	���BuildFileR3���R,��R=���R����R����Rm��R���(���R����t���dept���opt���all_dependency_sectionsR����R����t���target_build_fileR)���t���dependency_keyR���RU���t���dep_filet
���dep_targett���dep_toolsetR����(����(����s ���externals/gyp/pylib/gyp/input.pyt���QualifyDependencies��s*����


			
c���������C���s���x�|��j�����D]�\�}�}�|�d�}�t�j�j�|���}�x�t�D]�}�|�j�|�g����}�d�}�xb|�t�|���k��r�t�j�j�|�|���\�}	�}
�}�|
�d�k�r��|�d�k�r��|�d�}�q]�n��|	�|�k�r��t�d�|�d�|�d�����n��|�|�=|�d�}�|�|	�d�}�x��|�D]��}
�t	�|
�j�d	�t
�����r+qn��|
�d
�}�|
�d�k�rS|
�|�k�rSqn��|
�d�}�|�d�k�r{|�|�k�r{qn��t�j�j�|	�|�|���}�|�d�}�|�j�|�|���qW|�d�}�q]�Wq<�Wq
�Wd�S(���s���Expands dependencies specified as build_file:*.

  For each target in |targets|, examines sections containing links to other
  targets.  If any such section contains a link of the form build_file:*, it
  is taken as a wildcard link, and is expanded to list each target in
  build_file.  The |data| dict provides access to build file dicts.

  Any target that does not wish to be included by wildcard can provide an
  optional "suppress_wildcard" key in its target dict.  When present and
  true, a wildcard dependency link will not include such targets.

  All dependency names, including the keys to |targets| and the values in each
  dependency list, must be qualified when this function is called.
  R)���i����t���*i���s���Found wildcard in s��� of s��� referring to same build fileR����R'���R(���N(
���Rv���Rc���Rd���Rp��Ro��R3���R=���t���ParseQualifiedTargetR���R��Ru���Rm��t���insert(���R����Rg���R����R����R)���Rt��Ru��R���RU���t���dependency_build_filet���dependency_targett���dependency_toolsett���dependency_target_dictst���dependency_target_dictt���dependency_target_namet���dependency_target_toolsetR����(����(����s ���externals/gyp/pylib/gyp/input.pyt���ExpandWildcardDependencies>��sD����






	
c���������C���s5���i��}�g��|��D]$�}�|�|�k�r
�|�j��|�|���^�q
�S(���s=���Removes duplicate elements from l, keeping the first element.(���t
���setdefault(���t���lt���seenRm���(����(����s ���externals/gyp/pylib/gyp/input.pyt���Unify���s����c���������C���s]���xV�|��j�����D]H�\�}�}�x9�t�D]1�}�|�j�|�g����}�|�r �t�|���|�|�<q �q �Wq
�Wd�S(���sR���Makes sure every dependency appears only once in all targets's dependency
  lists.N(���Rv���Ro��R3���R���(���R����R(���R����Ru��R���(����(����s ���externals/gyp/pylib/gyp/input.pyt���RemoveDuplicateDependencies���s
����
c���������C���s5���i��}�g��|��D]$�}�|�|�k�r
�|�j��|�|���^�q
�S(���s���Removes item from l.(���R���(���R���R����t���resRm���(����(����s ���externals/gyp/pylib/gyp/input.pyt���Filter���s����c���������C���s����x��|��j�����D]��\�}�}�x��t�D]y�}�|�j�|�g����}�|�r �xX�|�D]M�}�|�|�k�rE�|��|�j�d�i����j�d�d���r��t�|�|���|�|�<q��qE�qE�Wq �q �Wq
�Wd�S(���sY���Remove self dependencies from targets that have the prune_self_dependency
  variable set.R,���t���prune_self_dependencyi����N(���Rv���Ro��R3���R���(���R����R(���R����Ru��R���t���t(����(����s ���externals/gyp/pylib/gyp/input.pyt���RemoveSelfDependencies���s����

"t���DependencyGraphNodec�����������B���s����e��Z�d��Z�d�e�f�d�������YZ�d����Z�d����Z�d����Z�d�d���Z	�d�d���Z
�d�d���Z�d�d	���Z�d�d
���Z
�d�e�d���Z�d����Z�d
����Z�RS(���s����

  Attributes:
    ref: A reference to an object that this DependencyGraphNode represents.
    dependencies: List of DependencyGraphNodes on which this one depends.
    dependents: List of DependencyGraphNodes that depend on this one.
  t���CircularExceptionc�����������B���s���e��Z�RS(����(���R����R����(����(����(����s ���externals/gyp/pylib/gyp/input.pyR������s���c���������C���s���|�|��_��g��|��_�g��|��_�d��S(���N(���t���refR���t
���dependents(���R����R���(����(����s ���externals/gyp/pylib/gyp/input.pyR�������s����		c���������C���s���d�|��j��S(���Ns���<DependencyGraphNode: %r>(���R���(���R����(����(����s ���externals/gyp/pylib/gyp/input.pyt���__repr__���s����c���������C���s����g��}�t��|��j���}�x��|�r��|�j����}�|�j�|�j���xZ�|�j�D]O�}�t�}�x*�|�j�D]�}�|�j�|�k�r[�t�}�Pq[�q[�W|�rE�|�j�|���qE�qE�Wq�W|�S(���N(	���R����R���R����R2���R���R����R���Ru���R����(���R����t	���flat_listt���in_degree_zerosRM���t���node_dependentt���is_in_degree_zerot���node_dependent_dependency(����(����s ���externals/gyp/pylib/gyp/input.pyt
���FlattenToList���s����	c���������C���s����|�d�k�r�|��g�}�n��g��}�x��|��j�D]|�}�|�|�k�r��|�g�}�x+�|�D]#�}�|�j�|���|�|�k�rJ�PqJ�qJ�W|�j�t�|�����q(�|�j�|�j�|�g�|�����q(�Wt�t�|�����S(���sR���
    Returns a list of cycles in the graph, where each cycle is its own list.
    N(���R1���R���R2���t���tupleRo���t
���FindCyclesRJ���R����(���R����RZ���t���resultsRM���t���cyclet���part(����(����s ���externals/gyp/pylib/gyp/input.pyR������s����	

!c���������C���s^���|�d�k�r�g��}�n��xB�|��j�D]7�}�|�j�d�k�r�|�j�|�k�r�|�j�|�j���q�q�W|�S(���s+���Returns a list of just direct dependencies.N(���R1���R���R���R2���(���R����R���R����(����(����s ���externals/gyp/pylib/gyp/input.pyt���DirectDependencies���s����	c���������C���s����|�d�k�r�g��}�n��d�}�x��|�t�|���k��r��|�|�}�|�|�}�d�}�xG�|�j�d�g����D]3�}�|�|�k�r]�|�j�|�|�|���|�d�}�q]�q]�W|�d�}�q�W|�S(���s^��Given a list of direct dependencies, adds indirect dependencies that
    other dependencies have declared to export their settings.

    This method does not operate on self.  Rather, it operates on the list
    of dependencies in the |dependencies| argument.  For each dependency in
    that list, if any declares that it exports the settings of one of its
    own dependencies, those dependencies whose settings are "passed through"
    are added to the list.  As new items are added to the list, they too will
    be processed, so it is possible to import settings through multiple levels
    of dependencies.

    This method is not terribly useful on its own, it depends on being
    "primed" with a list of direct dependencies such as one provided by
    DirectDependencies.  DirectAndImportedDependencies is intended to be the
    public entry point.
    i����i���R���N(���R1���R=���R3���R|��(���R����R����R���RU���R����t���dependency_dictt	���add_indext���imported_dependency(����(����s ���externals/gyp/pylib/gyp/input.pyt���_AddImportedDependencies��s����	

c���������C���s���|��j��|���}�|��j�|�|���S(���s����Returns a list of a target's direct dependencies and all indirect
    dependencies that a dependency has advertised settings should be exported
    through the dependency for.
    (���R���R���(���R����R����R���(����(����s ���externals/gyp/pylib/gyp/input.pyt���DirectAndImportedDependencies.��s����c���������C���sk���|�d�k�r�g��}�n��xO�|��j�D]D�}�|�j�d�k�r�|�j�|�k�r�|�j�|�j���|�j�|���q�q�W|�S(���s>���Returns a list of all of a target's dependencies, recursively.N(���R1���R���R���R2���t���DeepDependencies(���R����R���R����(����(����s ���externals/gyp/pylib/gyp/input.pyR���7��s����	c���������C���s���|�d
�k�r�g��}�n��|��j�d
�k�r(�|�Sd�|�|��j�k�rJ�t�d�����n��d�|�|��j�k�r{�t�d�|�|��j�d�����n��|�|��j�d�}�|�t�k�}�|�r��|�r��|�S|�d�k�r��|�|��j�j�d�t���r��|��j�|�k�r��|�j�|��j���n��|�S|�r|�d�k�r|�S|�r*|�d	�k�r*|�r*|�S|��j�|�k�r�|�j�|��j���|�sV|�r�x*�|��j�D]�}�|�j�|�|�|�t	���q`Wq�n��|�S(���sj��Returns a list of dependency targets that are linked into this target.

    This function has a split personality, depending on the setting of
    |initial|.  Outside callers should always leave |initial| at its default
    setting.

    When adding a target to the list of dependencies, this function will
    recurse into itself with |initial| set to False, to collect dependencies
    that are linked into the linkable target for which the list is being built.

    If |include_shared_libraries| is False, the resulting dependencies will not
    include shared_library targets that are linked into this target.
    R(���s&���Missing 'target_name' field in target.R+���s!���Missing 'type' field in target %st���nonet���dependencies_traverseR���R
���R	���N(���s
���executableR
���(
���R1���R���R���t���linkable_typesR3���R����R2���R���t���_LinkDependenciesInternalRu���(���R����R����t���include_shared_librariesR���t���initialt���target_typet���is_linkableR����(����(����s ���externals/gyp/pylib/gyp/input.pyR���D��s>����	

	c���������C���s)���|�|��j��j�d�t���}�|��j�|�|���S(���si���
    Returns a list of dependency targets whose link_settings should be merged
    into this target.
    t(���allow_sharedlib_linksettings_propagation(���R���R3���R����R���(���R����R����R���(����(����s ���externals/gyp/pylib/gyp/input.pyt���DependenciesForLinkSettings���s����c���������C���s���|��j��|�t���S(���sP���
    Returns a list of dependency targets that are linked into this target.
    (���R���R����(���R����R����(����(����s ���externals/gyp/pylib/gyp/input.pyt���DependenciesToLinkAgainst���s����N(���R����R����R����R���R���R����R���R���R1���R���R���R���R���R���R����R���R���R���(����(����(����s ���externals/gyp/pylib/gyp/input.pyR������s���			*)	R	c���������C���sw��i��}�x9�|��j�����D]+�\�}�}�|�|�k�r�t�|���|�|�<q�q�Wt�d����}�x��|��j�����D]��\�}�}�|�|�}�t�j�j�|���}�|�j�d���}�|�s��|�g�|�_�|�j�j	�|���q[�x\�|�D]T�}�|�j�|���}	�|	�s��t
�d�|�|�f�����n��|�j�j	�|	���|	�j�j	�|���q��Wq[�W|�j����}
�t�|
���t�|����k�rmt�j
�d�d�j�t�|
���t�|����A������n��|�|
�g�S(���NR���s8���Dependency '%s' not found while trying to load target %ss@���Some targets not reachable, cycle in dependency graph detected: R��(���Rv���R���R1���Rc���Rd���Rp��R3���R���R���R2���R���R���R=���R���RI���R����(���R����t���dependency_nodesR����t���spect	���root_nodet���target_nodeRt��R���R����t���dependency_nodeR���(����(����s ���externals/gyp/pylib/gyp/input.pyt���BuildDependencyList���s2����

&c���������C���s���i��}�xE�|��j�����D]7�}�t�j�j�|���}�|�|�k�r�t�|���|�|�<q�q�Wx|��j����D]��\�}�}�t�j�j�|���}�|�|�}�|�j�d�g����}�x��|�D]��}�y�t�j�j�|���}�Wn-�t�k
�r��}	�t�j�j�|	�d�|������n�X|�|�k�r��q��n��|�j�|���}
�|
�s"t�d�|�����n��|
�|�j	�k�r��|�j	�j
�|
���|
�j�j
�|���q��q��Wq[�Wt�d����}�xL�|�j
����D]>�}�t�|�j	���d�k�ru|�j	�j
�|���|�j�j
�|���ququW|�j����}�t�|���t�|���k�r�g��}
�x0�|�j�����D]"�}�|�|�k�r�|
�j
�|���q�q�Wt�j�j�|���}�g��}�xw�|�j����D]i�}�g��}�x@�|�D]8�}�|�j�j�|���sjt���|�j
�|�j�t�|�����qLW|�j
�d�d�j�|�����q9Wt�j�d�d�j�|�����n��d��S(	���NR���s,���while computing dependencies of .gyp file %ss���Dependancy '%s' not foundi����s	���Cycle: %ss��� -> s/���Cycles in .gyp file dependency graph detected:
s���
(���t���iterkeysRc���Rd���Rp��R���Rv���R3���R���Re���R���R2���R���R1���t
���itervaluesR=���R���RY���RZ���t���commonprefixR���R���t
���startswithR;���RI���R���(���R����R���R����R/��R���t���build_file_nodet���target_dependenciesR����R}��Rm���R���R���R���t	���bad_filest���filet���common_path_prefixt���cyclesR���t���simplified_pathsRM���(����(����s ���externals/gyp/pylib/gyp/input.pyt#���VerifyNoGYPFileCircularDependencies���sZ����

	
c���������C���s����x��|�D]��}�|�|�}�t��j�j�|���}�|��d�k�rH�|�|�j����}�nT�|��d�k�rj�|�|�j�|���}�n2�|��d�k�r��|�|�j�|���}�n�t�d�|������xS�|�D]K�}�|�|�}	�|��|	�k�r��q��n��t��j�j�|���}
�t�|�|	�|��|�|
���q��Wq�Wd��S(���NR-���R.���R/���sC���DoDependentSettings doesn't know how to determine dependencies for (���Rc���Rd���Rp��R���R���R���R���Rt���(���RR���R���R����R���R����R����R/��R���R����R���R}��(����(����s ���externals/gyp/pylib/gyp/input.pyt���DoDependentSettings��s$����





c���
������C���s���x�|��D]�}�|�|�}�|�d�}�|�d�k�rd�|�k�r?�q�n��|�j��d�g����|�d�<|�|�j�|���}�d�}�x��|�t�|���k��r��|�|�}	�|�|	�}
�|
�d�d�k�r��|
�j��d�t���s��|
�d�d�k�r��|	�|�d�k�r��|�|�=qr�|�d�}�qr�Wt�|���d�k�r|�|�d�<q�|�d�=q�|�t�k�r�|�|�j�|���}�x]�|�D]U�}	�|	�|�k�rZqBn��d�|�k�rsg��|�d�<n��|	�|�d�k�rB|�d�j�|	���qBqBW|�r�d�|�k�r�g��t�|����D]�}�|�|�d�k�r�|�^�q�|�d�<q�q�q�Wd��S(���NR+���t���static_libraryR���R���i����t���hard_dependencyi���(���R3���R���R=���Ru���R���R���R2���t���reversed(
���R���R����R���t���sort_dependenciesR����R����R���R���RU���R����R���t���link_dependenciesRq��(����(����s ���externals/gyp/pylib/gyp/input.pyt���AdjustStaticLibraryDependencies.��sD����









s
���["']?[-/$<>^]c���������C���s����|��|�k�s�t��j�|���r�|�St�j�j�t�j�j�t�j�j�t�j�j	�|���t�j�j	�|������|�����j
�d�d���}�|�d�d�k�r��|�d�7}�n��|�Sd��S(���Ns���\R����i����(���t���exception_reR����RY���RZ���Rp���RI���Rc���Rd���R����Rq���R����(���t���to_filet���fro_fileR����t���ret(����(����s ���externals/gyp/pylib/gyp/input.pyt���MakePathRelative��s����
c������������s���d����������f�d����}�d�}�t�����f�d����|��D����}�x�|�D]�}	�t�}
�t�|	�t���sk�t�|	�t���r��|�r��t�|�|�|	���}�n�|	�}�t�|	�t���s��|	�j�d���r!t�}
�q!ni�t�|	�t���r��i��}�t	�|�|	�|�|���n>�t�|	�t
���rg��}�t�|�|	�|�|���n�t�d�|	�j
�j���|�rp|
�sA|�|�|�|����r�|��j�|������|���rm|�j�|���qmq�qA�x#�|
�r�|�|��k�r�|��j�|���qsW|��j�|�|������|���r�|�j�|���n��|�d�}�qA�Wd��S(���Nc���������S���s���|��j��S(���N(���t���__hash__(���t���val(����(����s ���externals/gyp/pylib/gyp/input.pyt���<lambda>���s����c������������s ������|����r�|��|�k�S|��|�k�S(���N(����(���t���xt���sR���(���t���is_hashable(����s ���externals/gyp/pylib/gyp/input.pyt���is_in_set_or_list���s����
i����c���������3���s!���|��]�}����|���r�|�Vq�d��S(���N(����(���t���.0R���(���R���(����s ���externals/gyp/pylib/gyp/input.pys	���<genexpr>���s����t���-s/���Attempt to merge list item of unsupported type i���(���R����Ru���R:���R����R��R���R���R����RP���Rt���RJ���t
���MergeListsRL���Rw���R����R2���R����t���removeR|��(���t���tot���froR���R���t���is_pathsR2���R���t
���prepend_indext���hashable_to_setR����t	���singletont���to_item(����(���R���s ���externals/gyp/pylib/gyp/input.pyR������s@����	
 

c���������C���s;��x4|�j�����D]&\�}�}�|�|��k�r��t�}�t�|�t���sI�t�|�t���r{�t�|��|�t���pl�t�|��|�t���s��t�}�q��n�|�j�|��|�j�k�r��t�}�n��|�r��t�d�|�j�j�d�|��|�j�j�d�|���q��n��t�|�t���s��t�|�t���r)t	�|���}�|�rt
�|�|�|���|��|�<q3|�|��|�<q
�t�|�t���rk|�|��k�rQi��|��|�<n��t�|��|�|�|�|���q
�t�|�t
���r|�d�}�t�}	�|�d�k�r�|�d� }
�|
�|
�d�g�}�g��|��|
�<n}�|�d�k�r�|�d� }
�|
�d�|
�d�g�}�t�}	�nJ�|�d�k�r |�d� }
�|
�|
�d�|
�d�g�}�n�|�}
�|
�d�|
�d�g�}�x5�|�D]-�}�|�|�k�rAt�d�|�d	�|�����qAqAW|
�|��k�r�|�d�k�r�q
�n��t�|��|
�t
���s�t�d�|�j�j�d�|��|
�j�j�d�|
�d
�|�d���q�n
�g��|��|
�<t	�|
���}
�t�|��|
�|�|�|�|
�|	���q
�t�d�|�j�j�d�|���q
�Wd��S(
���Ns$���Attempt to merge dict value of type s��� into incompatible type s	��� for key i����t���=t���?t���+s���Incompatible list policies s��� and R����R����s0���Attempt to merge dict value of unsupported type (���Rv���Ru���R:���R����R��R����Rw���RL���R����R���R���RP���Rt���RJ���R���R���(���R���R���R���R���R~���R���t	���bad_merget���is_patht���extR2���t	���list_baset���lists_incompatiblet���list_incompatibleR���(����(����s ���externals/gyp/pylib/gyp/input.pyRt������sf����&	0





	

<
 c���������C���s����|�|�k�r�d��S|�d�|�}�x7�|�j��d�g����D]#�}�t�|��|�|�|�|�|�g���q1�Wt�|��|�|�|���d�|��k�r��|��d�=n��d��S(���NR���t���inherit_fromt���abstract(���R3���t���MergeConfigWithInheritanceRt���(���t���new_configuration_dictR/��R����t
���configurationt���visitedt���configuration_dictt���parent(����(����s ���externals/gyp/pylib/gyp/input.pyR���J��s����		
c���������C���s���d�d�d�d�d�g�}�t��j�j�|����}�d�|�k�rG�i�i��d�6|�d�<n��d�|�k�r��g��|�d�j����D]#�}�|�d�|�j�d	���sd�|�^�qd�}�t�|���d
�|�d�<n��x��|�d�j����D]��}�|�d�|�}�|�j�d	���r��q��n��t�j�|���}�g��}	�xS�|�D]K�}
�|
�d�}�|�|�k�r#|
�d� }�n�|
�}�|�t	�k�r��|	�j
�|
���q��q��Wx�|	�D]
�}
�|�|
�=qPWt�|�|�|�|�g����|�|�d�|�<q��WxC�|�d�j����D]1�}�|�d�|�}�|�j�d	���r�|�d�|�=q�q�Wg��}	�xS�|�D]K�}
�|
�d�}�|�|�k�r|
�d� }�n�|
�}�|�t	�k�r�|	�j
�|
���q�q�Wx�|	�D]
�}
�|�|
�=q2Wxe�|�d�j����D]S�}�|�d�|�}
�x<�|
�j����D].�}
�|
�t�k�rut
�d�|
�|�|��f�����ququWqTWd��S(
���NR���R���R���R����R����R���t���DefaultR���R���i����i����s:���%s not allowed in the %s configuration, found in target %s(���Rc���Rd���Rp��R���R3���t���sortedt���keysR����R����R����R2���R���t���invalid_configuration_keysR���(���R����R����t���key_suffixesR/��RE��t���concreteR���t���old_configuration_dictR���t���delete_keysRR���t���key_extt���key_baseR���(����(����s ���externals/gyp/pylib/gyp/input.pyt���SetUpConfigurationsa��s\����#



	




c���������C���s���g��}�g��}�x|�j�����D]\�}�}�|�d�}�|�d�k�rM�|�d�k�rM�q�n��t�|�t���s~�t�|��d�|�d�|�j�j���n��|�d� }�|�|�k�r��|�j�|���q�n��t�|�|�t���s�|�|�}�t�|��d�|�d�|�j�j�d�i�d�d�6d�d�6|���n��|�|�k�r�|�j�|���q�q�Wx�|�D]
�}�|�|�=q'WxB|�D]:}�|�|�}	�t�d�t�|	�����}
�|�d�}�|�|�k�r�xO�|�|�D]C�}�x:�t�d	�t�|	�����D]#�}
�|�|	�|
�k�r�d	�|
�|
�<q�q�Wq�W|�|�=n��|�d�}�|�|�k�r�x��|�|�D]��}�|�\�}�}�t	�j
�|���}�|�d
�k�r.d	�}�n2�|�d�k�rCd�}�n�t�d
�|�d�|��d�|���xY�t�d	�t�|	�����D]B�}
�|	�|
�}�|
�|
�|�k�r�qvn��|�j�|���rv|�|
�|
�<qvqvWq�W|�|�=n��|�d�}�|�|�k�r�t�|��d�|�d�|�����n��g��}�xR�t�t�|
���d�d�d���D]4�}
�|
�|
�d	�k�r"|�j
�d	�|	�|
���|	�|
�=q"q"Wt�|���d	�k�r?|�|�|�<q?q?WxX�|�j�����D]J�\�}�}�t�|�t���r�t�|�|���q�t�|�t���r�t�|�|���q�q�Wd�S(���s���Process regular expression and exclusion-based filters on lists.

  An exclusion list is in a dict key named with a trailing "!", like
  "sources!".  Every item in such a list is removed from the associated
  main list, which in this example, would be "sources".  Removed items are
  placed into a "sources_excluded" list in the dict.

  Regular expression (regex) filters are contained in dict keys named with a
  trailing "/", such as "sources/" to operate on the "sources" list.  Regex
  filters in a dict take the form:
    'sources/': [ ['exclude', '_(linux|mac|win)\.cc$'],
                  ['include', '_mac\.cc$'] ],
  The first filter says to exclude all files ending in _linux.cc, _mac.cc, and
  _win.cc.  The second filter then includes all files ending in _mac.cc that
  are now or were once in the "sources" list.  Items matching an "exclude"
  filter are subject to the same processing as would occur if they were listed
  by name in an exclusion list (ending in "!").  Items matching an "include"
  filter are brought back into the main list if previously excluded by an
  exclusion list or exclusion regex filter.  Subsequent matching "exclude"
  patterns can still cause items to be excluded after matching an "include".
  i����R����R����s��� key s��� must be list, not s��� when applying t	���exclusiont���regexi����t���excludeR|���i���s���Unrecognized action s��� in t	���_excludedsD��� must not be present prior  to applying exclusion/regex filters for N(���i����(���Rv���R:���RJ���RR��Rw���R����R2���R=���R,��R����RT��R���R���R|��RP���R��t���ProcessListFiltersInList(���t���nameRY��t���listst	���del_listsRR���R����t	���operationt���list_keyt���del_listRl��t���list_actionst���exclude_keyt���exclude_itemRU���t	���regex_keyt
���regex_itemt���actiont���patternt
���pattern_ret���action_valuet	���list_itemt���excluded_keyt
���excluded_list(����(����s ���externals/gyp/pylib/gyp/input.pyR�����s�����









		


#c���������C���sS���xL�|�D]D�}�t��|�t���r,�t�|��|���q�t��|�t���r�t�|��|���q�q�Wd��S(���N(���R:���RP���R��RJ���R��(���R��Rl��R����(����(����s ���externals/gyp/pylib/gyp/input.pyR��S	��s
����
c���������C���s����d
�}�|�j��d�d���}�|�|�k�rI�t�d�|��|�d�j�|���f�����n��|�j��d	�d
���r��|�d�k�r��t�d�|��|�f�����n��d�S(���s����Ensures the 'type' field on the target is one of the known types.

  Arguments:
    target: string, name of target.
    target_dict: dict, target spec.

  Raises an exception on error.
  R���R
���R���R	���R���R+���s>���Target %s has an invalid target type '%s'.  Must be one of %s.R����R&���i����s_���Target %s has type %s but standalone_static_library flag is only valid for static_library type.N(���s
���executables���loadable_modules���static_librarys���shared_librarys���none(���R3���R1���R���RI���(���R����R����t���VALID_TARGET_TYPESR���(����(����s ���externals/gyp/pylib/gyp/input.pyt���ValidateTargetType[	��s����	��
c������
���C���s��|�j��d�d����d�k�r�d��S|�j��d�g����}�i��}�xi�|�D]a�}�t�j�j�|���\�}�}�|�d�k�}�|�sq�q;�n��t�j�j�|���}	�|�j�|	�g����j�|���q;�Wd
�}
�xL�|�j����D]>�\�}	�}�t	�|���d�k�r��|
�d�|	�d�j
�|���f�7}
�q��q��W|
�rd�|��|
�d�GHt�d�����n��d��S(���NR+���R���R	���R���s���.cs���.ccs���.cpps���.cxxs���.ms���.mms���.ss���.SR����i���s	���  %s: %s
R��s<���static library %s has several files with the same basename:
s4���Some build systems, e.g. MSVC08, cannot handle that.s6���Duplicate basenames in sources section, see list above(���s���static_librarys���shared_library(���s���.cs���.ccs���.cpps���.cxxs���.ms���.mms���.ss���.S(���R3���R1���RY���RZ���t���splitextt���basenameR���R2���Rv���R=���RI���R���(���R����R����R/��R���t	���basenamest���sourceR��R���t���is_compiled_fileR��R����R���(����(����s ���externals/gyp/pylib/gyp/input.pyt���ValidateSourcesInTargets	��s&����
	$c���������C���s���i��}�i��}�|�j��d�g����}�x�|�D]�}�|�d�}�|�|�k�rZ�t�d�|�|��f�����n��|�|�|�<|�d�}�|�j�d���r��|�d�}�n��|�|�k�r��t�d�d�|�|��|�|�d�|�f�����n��|�|�|�<d	�|�k�r��t�d
�|��|�f�����n��g��}	�d�g�}
�|
�j�|���x{�|
�D]s�}�xj�|�j��|�g����D]V�}�t�j�j�|���\�}
�}�|�j�d���rf|�d�}�n��|�|�k�r,|	�j�|���q,q,WqWt�|	���d�k�r%�|	�|�d	�<q%�q%�Wd
�S(���s]��Ensures that the rules sections in target_dict are valid and consistent,
  and determines which sources they apply to.

  Arguments:
    target: string, name of target.
    target_dict: dict, target spec containing "rules" and "sources" lists.
    extra_sources_for_rules: a list of keys to scan for rule matches in
        addition to 'sources'.
  R$���t	���rule_names&���rule %s exists in duplicate, target %st	���extensionRE���i���s-���extension %s associated with multiple rules, s���target %s rules %s and %st���rule_sourcess7���rule_sources must not exist in input, target %s rule %sR���i����N(	���R3���R���R���Ro���RY���RZ���R��R2���R=���(���R����R����t���extra_sources_for_rulest
���rule_namest���rule_extensionsR$���t���ruleR��t���rule_extensionR��t���source_keyst
���source_keyR��t���source_roott���source_extension(����(����s ���externals/gyp/pylib/gyp/input.pyt���ValidateRulesInTarget�	��sF����






	


c���������C���s&��|�j��d���}�|�j��d���}�|�s(�d��St�|�t���sP�t�d�|�|�f�����n��|�j��d���}�|�s~�t�d�|�|�f�����n��t�|�t���s��t�d�|�|�f�����n��|�j��d���}�|�r��t�|�t���r��t�d�|�|�f�����n��|�j��d	���}�|�r"t�|�t���r"t�d
�|�|�f�����n��d��S(���NR(���R%���s>���The 'run_as' in target %s from file %s should be a dictionary.R
��sE���The 'run_as' in target %s from file %s must have an 'action' section.sC���The 'action' for 'run_as' in target %s from file %s must be a list.t���working_directorysP���The 'working_directory' for 'run_as' in target %s in file %s should be a string.t���environmentsN���The 'environment' for 'run_as' in target %s in file %s should be a dictionary.(���R3���R:���RP���R���RJ���R����(���R����R����R/��R(���R%���R
��R)��R*��(����(����s ���externals/gyp/pylib/gyp/input.pyt���ValidateRunAsInTarget�	��s,����c���	������C���s����|�j��d���}�|�j��d�g����}�x��|�D]��}�|�j��d���}�|�sV�t�d�|�����n��|�j��d�d
���}�|�d
�k�r��t�d�|�����n��|�j��d���}�|�r(�|�d�r(�t�d	�|�����q(�q(�Wd
�S(���s0���Validates the inputs to the actions in a target.R(���R���t���action_namesK���Anonymous action in target %s.  An action must have an 'action_name' field.R���s"���Action in target %s has no inputs.R
��i����s%���Empty action as command in target %s.N(���R3���R���R1���(	���R����R����R/��R(���R���R
��R,��R���t���action_command(����(����s ���externals/gyp/pylib/gyp/input.pyt���ValidateActionsInTarget�	��s����

c���������C���s����x��|��j�����D]��\�}�}�t�|�t���rA�t�|���}�|�|��|�<n8�t�|�t���r]�t�|���n�t�|�t���ry�t�|���n��t�|�t���r
�|�|��t�|���<|��|�=q
�q
�Wd�S(���sG���Given dict the_dict, recursively converts all integers into strings.
  N(���t���itemsR:���R��R����RP���t���TurnIntIntoStrInDictRJ���t���TurnIntIntoStrInList(���RY��R~���R���(����(����s ���externals/gyp/pylib/gyp/input.pyR0���	��s����


c���������C���s����x��t��d�t�|������D]j�}�|��|�}�t�|�t���rH�t�|���|��|�<q�t�|�t���rd�t�|���q�t�|�t���r�t�|���q�q�Wd�S(���sG���Given list the_list, recursively converts all integers into strings.
  i����N(	���R,��R=���R:���R��R����RP���R0��RJ���R1��(���Rl��RU���R����(����(����s ���externals/gyp/pylib/gyp/input.pyR1��
��s����

c���������C���so��g��}�xU�|�D]M�}�|�j�����}�t�j�j�|�|���}�|�sM�t�d�|�����n��|�j�|���q
�Wi��}�xE�|�D]=�}�|��|�|�|�<x&�|�|�j����D]�}	�|��|	�|�|	�<q��Wqk�Wg��|�D]�}
�|
�|�k�r��|
�^�q��}�x��|�d�D]��}�d�|�|�k�r��q��n��g��}
�xR�|�|�d�D]B�}�t�j�j�|�|�d�|�d���}�|�|�k�r
|
�j�|���q
q
W|
�|�|�d�<q��W|�|�f�S(���sE���Return only the targets that are deep dependencies of |root_targets|.s���Could not find target %sR����R����R(���R)���(	���R��Rc���Rd���t���FindQualifiedTargetsR���Ro���R���Rm��R2���(���R����R���R���t���root_targetsRg���t���qualified_root_targetsR����t���qualified_targetst���wanted_targetsR����R���t���wanted_flat_listR/��t���new_targetst���qualified_name(����(����s ���externals/gyp/pylib/gyp/input.pyt���PruneUnwantedTargets
��s2����

%
c���������C���s����i��}�x��|��D]��}�|�j��d�d���\�}�}�t�j�j�|���\�}�}�|�sR�d�}�n��|�d�|�}�|�|�k�r��t�d�|�|�|�|�|�f�����n��|�|�|�<q
�Wd�S(���s����Verify that no two targets in the same directory share the same name.

  Arguments:
    targets: A list of targets in the form 'path/to/file.gyp:target_name'.
  t���:i���RE���sH���Duplicate target name "%s" in directory "%s" used both in "%s" and "%s".N(���t���rsplitRY���RZ���R��R���(���R����t���usedR����RZ���R��t���subdirRc���RR���(����(����s ���externals/gyp/pylib/gyp/input.pyt���VerifyNoCollidingTargets;
��s����
	c���������C���sH���t��a�t�j�|��d���t�a�t�j�|��d���|��d�a�|��d�a�d��S(���NR���R����t$���generator_supports_multiple_toolsetsR��(���t���base_path_sectionsR���Ro���t���base_non_configuration_keysR����R����R��(���R����(����(����s ���externals/gyp/pylib/gyp/input.pyR����V
��s����c	������
���C���s���t��|���|�d�}	�i�t����d�6}
�i��}�t�t�t�j�j�|������}��|�rm�t�|��|
�|�|�|�|�|�|���nd�xa�|��D]Y�}�y#�t�|�|
�|�|�|�|�|�t���Wqt�t	�k
�r��}
�t
�j�j�|
�d�|������qt�Xqt�Wt
�|
���}�t�|���t�|���t�|�|
���x��|�j����D]��\�}�}�i��}�xM�t�D]E�}�x<�d�D]4�}�|�|�}�|�|�k�r1|�|�|�|�<|�|�=q1q1Wq$Wt�|�|���x�|�D]�}�|�|�|�|�<q�WqWt�|���|�r�t�|���n��t�|���\�}�}�|�r�t�|�|�|�|�|
���\�}�}�n��t�|���xY�d�d�d	�g�D]H�}�t�|�|�|�|���x,�|�D]$�}�|�|�|�k�r-|�|�|�=q-q-Wq
W|�}�|�d
�r�t�|�|�|�|�d���n��x=�|�D]5�}�|�|�}�t
�j�j�|���}�t�|�t�|�|���q�Wx%�|�D]�}�|�|�}�t�|�|���q�Wx%�|�D]�}�|�|�}�t�|�|���q�Wx=�|�D]5�}�|�|�}�t
�j�j�|���}�t�|�t�|�|���qWx��|�D]��}�|�|�}�t
�j�j�|���}�t �|�|���d�|�j!�d
�d���k�r�t"�|�|�|���n��t#�|�|�|	���t$�|�|�|���t%�|�|�|���qZWt&�|
���|�|�|
�g�S(���NR��R����s���while trying to load %sR����R����R����R-���R.���R/���t4���generator_wants_static_library_dependencies_adjustedt#���generator_wants_sorted_dependenciest���armt���target_arch(���R����R����R����('���R����R����t���mapRY���RZ���Rp���R����R����R����Rb���Rc���Rd���Re���Rn��Ry��R���R���Rv���Ro��R��R���R���R���R:��R?��R���R���Rp��R����R��R���R��R��R3���R��R(��R+��R.��R0��(���R����R,���Rh���R����R����Rj���t���circular_checkt���parallelR3��R��Rg���R6���R/��Rm���R����R(���R����t���tmp_dictR���Rr��RR���R���R���t
���settings_typeR����t���gii(����(����s ���externals/gyp/pylib/gyp/input.pyt���Loadi
��s�����

	



























(j���t���compiler.astR����R���R���R���R���R���R���R8���R����t
���gyp.commonRc���R����t���optparset���os.pathRY���R����R ��R����R%��R����R����t���timeR����R���R���Ro��RA��R���R����R���RT��R���R���RB��R����R���Ru���R����R1���R��R4���RD���R>���Rn���Rf���Rx���R����R����R����Rb���R����t���objectR����R����R����R����R����R����R����R��R
��R��R��R����R����R��R��R��Rc��Re��Rj��R����R*��Rn��Ry��R���R���R���R���R���R���R���R���R���R���R���R���R����R���Rt���R���R���R��R��R��R��R(��R+��R.��R0��R1��R:��R?��R����RM��(����(����(����s ���externals/gyp/pylib/gyp/input.pyt���<module>���s��				!			0	(		$	l	95	:								��<	V			o	"		'	E		
		
��	(	=		N	 H	c		T	�				:				
	#