File: //proc/self/root/lib64/python2.7/site-packages/mercurial/parser.pyc
�
1�3\c @@ s d d l m Z m Z d d l m Z d d l m Z m Z m Z d d l m
Z
d e f d � � YZ d � Z
d � Z d
� Z d � Z d � Z d
� Z d � Z d � Z d � Z d d d � Z d � Z d e f d � � YZ d e f d � � YZ d S( i ( t absolute_importt print_functioni ( t _( t errort pycompatt util( t
stringutilt parserc B@ sb e Z d
d � Z d � Z d � Z d � Z d
d � Z d d � Z d � Z d � Z
d � Z RS( c C@ s | | _ | | _ d | _ d S( N( t _elementst _methodst Nonet current( t selft elementst methods( ( s6 /usr/lib64/python2.7/site-packages/mercurial/parser.pyt __init__ s c C@ s" | j } t | j d � | _ | S( s advance the tokenizerN( R t nextt _iterR
( R t t( ( s6 /usr/lib64/python2.7/site-packages/mercurial/parser.pyt _advance$ s c C@ s t | j | j d d d !� S( s% True if next token may start new termi i i ( t anyR R ( R ( ( s6 /usr/lib64/python2.7/site-packages/mercurial/parser.pyt _hasnewterm) s c C@ sN | j d | k r@ t j t d � | j d | j d � � n | j � d S( s0 make sure the tokenizer matches an end conditioni s unexpected token: %si N( R R t
ParseErrorR R ( R t m( ( s6 /usr/lib64/python2.7/site-packages/mercurial/parser.pyt _match, s c C@ sK | r" | j d | k r" d } n | j | � } | rG | j | � n | S( sD gather right-hand-side operand until an end condition or binding meti N( R R
t _parseR ( R t bindR t expr( ( s6 /usr/lib64/python2.7/site-packages/mercurial/parser.pyt
_parseoperand2 s i c
C@ s[ | j � \ } } } | j | d d !\ } } | rW | oD | j � rW | | f } nB | r} | d | j | d � f } n t j t d � | | � � x� | | j | j d d k rV| j � \ } } } | j | d \ } } | r| o� | j � r| | f } q� | r7| d | | j | d � f } q� t j t d � | | � � q� W| S( Ni i i s not a prefix: %ss not an infix: %s( R R R R R R R R (
R R t tokent valuet post primaryt prefixR t infixt suffix( ( s6 /usr/lib64/python2.7/site-packages/mercurial/parser.pyR ; s !# c C@ s; | | _ | j � | j � } | j \ } } } | | f S( s! generate a parse tree from tokens( R R R R ( R t tokenitert resR R R ( ( s6 /usr/lib64/python2.7/site-packages/mercurial/parser.pyt parseQ s
c C@ sH t | t � s | S| j | d g | d D] } | j | � ^ q, � S( s4 recursively evaluate a parse tree using node methodsi i ( t
isinstancet tupleR t eval( R t treeR ( ( s6 /usr/lib64/python2.7/site-packages/mercurial/parser.pyR) X s c C@ s) | j | � } | j r% | j | � S| S( s< parse tokens into a parse tree and evaluate if methods given( R& R R) ( R R$ R ( ( s6 /usr/lib64/python2.7/site-packages/mercurial/parser.pyt __call__] s
N( t __name__t
__module__R
R R R R R R R& R) R+ ( ( ( s6 /usr/lib64/python2.7/site-packages/mercurial/parser.pyR s c C@ s� d } | j d � \ } } } | ry | j � } | sH t j d � � n t | � d k rl t j d � � n | d } n | j d � \ } } } | j � } | j � } | r� | s� t j d � � n | | d | d | f Sg d | | f S( s� Parse 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')
s **s no **optkey name providedi s! excessive **optkey names providedi t *s no *varkey name providedN( R
t partitiont splitR t ProgrammingErrort len( t spect optkeyt pret sept postt postst pres( ( s6 /usr/lib64/python2.7/site-packages/mercurial/parser.pyt splitargspecd s"
c @ s� | \ } } } } t � f d � t | � D� t | � � } | t | � k r t j t d � i | d 6t | � d 6� � n | r� | t | � t | � k r� t j t d � i | d 6t | � t | � d 6� � n t j � }
x+ t | | | � D] \ } } | |
| <q� W| r6| t |
� | !|
| <n7 x4 t | | t |
� | !� D] \ } } | |
| <qSW| r�t j � |
| <n x� | | D]� } | d � k s�| d d | k r�t j t d � i | d 6� � n | d d } | | k r|
}
n: | s1t j t d � i | d 6| d
6� � n
|
| }
| |
k rqt j t d � i | d 6| d
6� � n | d |
| <q�W|
S(
s� Build 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.
c 3@ s+ | ]! \ } } | d � k r | Vq d S( i N( ( t .0t it x( t keyvaluenode( s6 /usr/lib64/python2.7/site-packages/mercurial/parser.pys <genexpr>� s s6 %(func)s takes at least %(nargs)d positional argumentst funct nargss5 %(func)s takes at most %(nargs)d positional argumentsi i s %(func)s got an invalid arguments5 %(func)s got an unexpected keyword argument '%(key)s't keys; %(func)s got multiple values for keyword argument '%(key)s'i ( R t enumerateR2 R R R R t sortdictt zip( t treest funcnamet argspecR> t keynodet poskeyst varkeyt keysR4 t kwstartt argst kR= t d( ( R> s6 /usr/lib64/python2.7/site-packages/mercurial/parser.pyt
buildargsdict� sF !#
! )$
c C@ sI y t j | � SWn1 t k
rD } t j t j | � j � � � n Xd S( N( R t unescapestrt
ValueErrorR R R t bytestrt lower( t st e( ( s6 /usr/lib64/python2.7/site-packages/mercurial/parser.pyRQ � s c C@ s� t | t � s. | j | t j | � f � n� | d | k r� t t j | d � } | j | d | d d j | � f f � nn | j | d | d f � x) | d D] } t | | | d | � q� W| d d | d d d f g | d )d S( Ni i s (%s %s)t s (%si����t )( R' R( t appendR t pprintt mapt joint
_prettyformat( R* t leafnodest levelt linest rsRU ( ( s6 /usr/lib64/python2.7/site-packages/mercurial/parser.pyR] � s -c C@ s6 g } t | | d | � d j d � | D� � } | S( Ni s
c s@ s# | ] \ } } d | | Vq d S( s N( ( R; t lRU ( ( s6 /usr/lib64/python2.7/site-packages/mercurial/parser.pys <genexpr>� s ( R] R\ ( R* R^ R` t output( ( s6 /usr/lib64/python2.7/site-packages/mercurial/parser.pyt prettyformat� s c @ s� t | t � s | S| d } | � k rN | f t � f d � | d D� � Sg } | } x@ | d | k r� | d \ } } | j t | � � � | } q] W| j t | � � � | j | � t t | � � S( s_ 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')))
i c 3@ s | ] } t | � � Vq d S( N( t simplifyinfixops( R; R= ( t targetnodes( s6 /usr/lib64/python2.7/site-packages/mercurial/parser.pys <genexpr> s i ( R' R( RY Re t reversed( R* Rf t opt
simplifiedR= Rb t r( ( Rf s6 /usr/lib64/python2.7/site-packages/mercurial/parser.pyRe � s <
%
c @ sF | � k r � j � St | t � s) | St � � f d � | D� � S( Nc 3@ s! | ] } t | � � � Vq d S( N( t
_buildtree( R; R= ( t placeholdert replstack( s6 /usr/lib64/python2.7/site-packages/mercurial/parser.pys <genexpr>. s ( t popR' R( ( t templateRl Rm ( ( Rl Rm s6 /usr/lib64/python2.7/site-packages/mercurial/parser.pyRk ) s
c G@ sa t | t � s! t j d � � n t t | � � } t | | | � } | r] t j d � � n | S( s� 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')))
s placeholder must be a node tuples too many replacements( R' R( R R1 t listRg Rk ( Ro Rl t replsRm Rj ( ( s6 /usr/lib64/python2.7/site-packages/mercurial/parser.pyt buildtree0 s c @ s� | | k r t St | t � s0 t | t � r4 t S| � k ra | d � k ra � j | � t St | � t | � k r} t St � � � f d � t | | � D� � S( Ni c 3@ s- | ]# \ } } t | | � � � � Vq d S( N( t
_matchtree( R; t pR= ( t incompletenodest matchesRl ( s6 /usr/lib64/python2.7/site-packages/mercurial/parser.pys <genexpr>N s ( t TrueR' R( t FalseRY R2 t allRD ( t patternR* Rl Ru Rv ( ( Ru Rv Rl s6 /usr/lib64/python2.7/site-packages/mercurial/parser.pyRs D s
c C@ sW | d k r. t | t � r. t j d � � n | g } t | | | | | � rS | Sd S( s 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')))
s placeholder must be a node tupleN( R
R' R( R R1 Rs ( Rz R* Rl Ru Rv ( ( s6 /usr/lib64/python2.7/site-packages/mercurial/parser.pyt matchtreeQ s
" c C@ sF t | j � d k r7 t d � | j d | j d f S| j d Sd S( s; Compose error message from specified ParseError object
i s at %d: %si N( R2 RM R ( t inst( ( s6 /usr/lib64/python2.7/site-packages/mercurial/parser.pyt parseerrordetaily s "t aliasc B@ s e Z d Z d � Z RS( s Parsed result of aliasc C@ s1 | | _ | | _ | | _ | | _ t | _ d S( N( t nameRM R t replacementRx t warned( R R RM t errR� ( ( s6 /usr/lib64/python2.7/site-packages/mercurial/parser.pyR � s
( R, R- t __doc__R ( ( ( s6 /usr/lib64/python2.7/site-packages/mercurial/parser.pyR~ � s t basealiasrulesc B@ s� e Z d Z d Z d Z d � Z e d � � Z e d � � Z e
d � � Z e
d � � Z e
d � � Z
e
d � � Z e
d � � Z e
d
� � Z e
d � � Z e
d � � Z e
d
� � Z RS( sw 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)
t symbolc C@ s t d | j � � d S( Ns '%s' is not instantiatable( t TypeErrorR, ( t cls( ( s6 /usr/lib64/python2.7/site-packages/mercurial/parser.pyt __new__� s c C@ s
t � d S( s- Parse an alias name, arguments and definitionN( t NotImplementedError( R3 ( ( s6 /usr/lib64/python2.7/site-packages/mercurial/parser.pyR � s c C@ s
t � d S( s9 Return (name, args) if tree is a function; otherwise NoneN( R� ( R* ( ( s6 /usr/lib64/python2.7/site-packages/mercurial/parser.pyt _trygetfunc� s c @ sj y � j | � } Wn& t j k
r; } | d
t | � f SX| d � j k r� | d } | j d � r | d
t d � | f S| d
d
f S� j | � } | rW| \ } } | j d � r� | d
t d � | f St � f d � | D� � r| d
t d � f St
| � t
t | � � k r3| d
t d � f S| g | D] } | d ^ q=d
f S| d
t d � f S( s�
Parse 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')
i i t $s invalid symbol '%s's invalid function '%s'c 3@ s" | ] } | d � j k Vq d S( i N( t _symbolnode( R; R ( R� ( s6 /usr/lib64/python2.7/site-packages/mercurial/parser.pys <genexpr> s s invalid argument lists& argument names collide with each others invalid formatN( R R R R
R} R� t
startswithR R� R R2 t set( R� t declR* R| R R? RM R ( ( R� s6 /usr/lib64/python2.7/site-packages/mercurial/parser.pyt
_builddecl� s( M
$c @ s� t | t � s | S| d } | � j k rT | f t � � f d � | d D� � St | � d k sl t � | d } | � k r� d } n+ | j d � r� t j t d � | � � n | | f S( s% Mark alias arguments as ``_aliasarg``i c 3@ s! | ] } � j | � � Vq d S( N( t _relabelargs( R; R= ( RM R� ( s6 /usr/lib64/python2.7/site-packages/mercurial/parser.pys <genexpr> s i i t _aliasargR� s invalid symbol '%s'( R' R( R� R2 t AssertionErrorR� R R R ( R� R* RM Rh t sym( ( RM R� s6 /usr/lib64/python2.7/site-packages/mercurial/parser.pyR� s
(
c C@ s= | j | � } | r$ t | � } n t � } | j | | � S( s� 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� t defnRM R* ( ( s6 /usr/lib64/python2.7/site-packages/mercurial/parser.pyt
_builddefn$ s
/ c C@ s� d } } | j | � \ } } } | r7 t d � } nG y | j | | � } Wn. t j k
r} } t | � } t d � } n X| r� | i | j d 6| d 6| d 6} n t | | | | � S( s> Parse an alias declaration and definition into an alias objects4 bad declaration of %(section)s "%(name)s": %(error)ss3 bad definition of %(section)s "%(name)s": %(error)st sectionR R N( R
R� R R� R R R} t _sectionR~ ( R� R� R� t replt efmtR RM R� R| ( ( s6 /usr/lib64/python2.7/site-packages/mercurial/parser.pyt buildZ s
%c C@ s@ i } x3 | D]+ \ } } | j | | � } | | | j <q
W| S( sT Parse a list of alias (name, replacement) pairs into a dict of
alias objects( R� R ( R� t itemst aliasesR� R� t a( ( s6 /usr/lib64/python2.7/site-packages/mercurial/parser.pyt buildmapk s
c C@ s� t | t � s d S| d | j k ra | d } | j | � } | ra | j d k ra | d f Sn | j | � } | r� | \ } } | j | � } | r� | j d k r� | | f Sn d S( sr If tree looks like an unexpanded alias, return (alias, pattern-args)
pair. Return None otherwise.
i i N( R' R( R
R� t getRM R� ( R� R� R* R R� R? RM ( ( s6 /usr/lib64/python2.7/site-packages/mercurial/parser.pyt _getaliasu s
c @ sR t | t � s | S| d d k r5 | d } � | St � � f d � | D� � S( so Replace _aliasarg instances with the substitution value of the
same name in args, recursively.
i R� i c 3@ s! | ] } � j | � � Vq d S( N( t _expandargs( R; R ( RM R� ( s6 /usr/lib64/python2.7/site-packages/mercurial/parser.pys <genexpr>� s ( R' R( ( R� R* RM R� ( ( RM R� s6 /usr/lib64/python2.7/site-packages/mercurial/parser.pyR� � s
c
@ s� t | t � s | S� j � | � } | d k rT t � � � � f d � | D� � S| \ } } | j r~ t j | j � � n | � k r� t j t d � i � j d 6| j d 6� � n � j
| � | j � k r� � j � | j � � � � | j <n � | j } � j
� | j d k r%| St | � t | j � k rbt j t d � t | � � � n g | D] } � j � | g � � ^ qi} � j | t t | j | � � � S( Nc 3@ s' | ] } � j � | � � � Vq d S( N( t _expand( R; R ( R� t cacheR� t expanding( s6 /usr/lib64/python2.7/site-packages/mercurial/parser.pys <genexpr>� s s5 infinite expansion of %(section)s "%(name)s" detectedR� R s invalid number of arguments: %d( R' R( R� R
R t AbortR R R� R RY R� R� Rn RM R2 R� t dictRD (
R� R� R* R� R� Rj R� Rb t resultR ( ( R� R� R� R� s6 /usr/lib64/python2.7/site-packages/mercurial/parser.pyR� � s2 !
+c C@ s | j | | g i � S( s Expand aliases in tree, recursively.
'aliases' is a dictionary mapping user defined aliases to alias objects.
( R� ( R� R� R* ( ( s6 /usr/lib64/python2.7/site-packages/mercurial/parser.pyt expand� s N( R, R- R� R
R� R� R� t staticmethodR R� t classmethodR� R� R� R� R� R� R� R� R� ( ( ( s6 /usr/lib64/python2.7/site-packages/mercurial/parser.pyR� � s g6
N( ( t
__future__R R t i18nR t R R R t utilsR t objectR R: RP RQ R] Rd Re Rk Rr Rs R
R{ R} R~ R� ( ( ( s6 /usr/lib64/python2.7/site-packages/mercurial/parser.pyt <module> s" E ! < O
(