HEX

File: //usr/lib/python2.7/dist-packages/mercurial/parser.pyc
�
�Xc@@s�ddlmZddlmZddlmZdefd��YZd�Zd�Z	d	�Z
d
�Zd�Zd�Z
d
efd��YZdefd��YZdS(i(tabsolute_importi(t_(terrortparsercB@sbeZd
d�Zd�Zd�Zd�Zd
d�Zdd�Zd�Z	d�Z
d	�ZRS(cC@s||_||_d|_dS(N(t	_elementst_methodstNonetcurrent(tselftelementstmethods((s4/usr/lib/python2.7/dist-packages/mercurial/parser.pyt__init__s		cC@s"|j}t|jd�|_|S(sadvance the tokenizerN(Rtnextt_iterR(Rtt((s4/usr/lib/python2.7/dist-packages/mercurial/parser.pyt_advances	cC@st|j|jddd!�S(s%True if next token may start new termiii(tanyRR(R((s4/usr/lib/python2.7/dist-packages/mercurial/parser.pyt_hasnewterm"scC@sN|jd|kr@tjtd�|jd|jd��n|j�dS(s0make sure the tokenizer matches an end conditionisunexpected token: %siN(RRt
ParseErrorRR(Rtm((s4/usr/lib/python2.7/dist-packages/mercurial/parser.pyt_match%scC@sK|r"|jd|kr"d}n|j|�}|rG|j|�n|S(sDgather right-hand-side operand until an end condition or binding metiN(RRt_parseR(RtbindRtexpr((s4/usr/lib/python2.7/dist-packages/mercurial/parser.pyt
_parseoperand+s	ic
C@s[|j�\}}}|j|dd!\}}|rW|oD|j�rW||f}nB|r}|d|j|d�f}ntjtd�||��x�||j|jddkrV|j�\}}}|j|d\}}	|	r|o�|j�r|	|f}q�|r7|d||j|d�f}q�tjtd�||��q�W|S(Niiisnot a prefix: %ssnot an infix: %s(RRRRRRRR(
RRttokentvaluetpostprimarytprefixRtinfixtsuffix((s4/usr/lib/python2.7/dist-packages/mercurial/parser.pyR4s  !# cC@s;||_|j�|j�}|j\}}}||fS(s!generate a parse tree from tokens(R
RRR(Rt	tokenitertresRRR((s4/usr/lib/python2.7/dist-packages/mercurial/parser.pytparseJs
	
cC@sHt|t�s|S|j|dg|dD]}|j|�^q,�S(s4recursively evaluate a parse tree using node methodsii(t
isinstancettupleRteval(RttreeR((s4/usr/lib/python2.7/dist-packages/mercurial/parser.pyR%QscC@s)|j|�}|jr%|j|�S|S(s<parse tokens into a parse tree and evaluate if methods given(R"RR%(RR R((s4/usr/lib/python2.7/dist-packages/mercurial/parser.pyt__call__Vs	
N(t__name__t
__module__RRRRRRRR"R%R'(((s4/usr/lib/python2.7/dist-packages/mercurial/parser.pyRs						cC@szt|�t|�krHtjtd�i|d6t|�d6��ni}x;t||�D]*\}}|d|kr~Pn|||<q^Wx�|t|�D]�}|d|ks�|dd|kr�tjtd�i|d6��n|dd}||kr.tjtd�i|d6|d6��n||krdtjtd	�i|d6|d6��n|d
||<q�W|S(s�Build dict from list containing positional and keyword arguments

    Invalid keywords or too many positional arguments are rejected, but
    missing arguments are just omitted.
    s*%(func)s takes at most %(nargs)d argumentstfunctnargsiis %(func)s got an invalid arguments5%(func)s got an unexpected keyword argument '%(key)s'tkeys;%(func)s got multiple values for keyword argument '%(key)s'i(tlenRRRtzip(ttreestfuncnametkeystkeyvaluenodetkeynodetargstktx((s4/usr/lib/python2.7/dist-packages/mercurial/parser.pyt
buildargsdict]s*!$cC@sFy|jd�SWn.tk
rA}tjt|�j���nXdS(Nt
string_escape(tdecodet
ValueErrorRRtstrtlower(tste((s4/usr/lib/python2.7/dist-packages/mercurial/parser.pytunescapestr}scC@s�t|t�s |d|kr<|j|t|�f�nn|j|d|df�x)|dD]}t|||d|�qbW|dd|dddfg|d)dS(Nis(%sii����t)(R#R$tappendR;t
_prettyformat(R&t	leafnodestleveltlinesR=((s4/usr/lib/python2.7/dist-packages/mercurial/parser.pyRB�s cC@s6g}t||d|�djd�|D��}|S(Nis
cs@s#|]\}}d||VqdS(s  N((t.0tlR=((s4/usr/lib/python2.7/dist-packages/mercurial/parser.pys	<genexpr>�s(RBtjoin(R&RCREtoutput((s4/usr/lib/python2.7/dist-packages/mercurial/parser.pytprettyformat�sc@s�t|t�s|S|d}|�krN|ft�fd�|dD��Sg}|}x@|d|kr�|d\}}|jt|���|}q]W|jt|���|j|�tt|��S(sFlatten chained infix operations to reduce usage of Python stack

    >>> def f(tree):
    ...     print prettyformat(simplifyinfixops(tree, ('or',)), ('symbol',))
    >>> f(('or',
    ...     ('or',
    ...       ('symbol', '1'),
    ...       ('symbol', '2')),
    ...     ('symbol', '3')))
    (or
      ('symbol', '1')
      ('symbol', '2')
      ('symbol', '3'))
    >>> f(('func',
    ...     ('symbol', 'p1'),
    ...     ('or',
    ...       ('or',
    ...         ('func',
    ...           ('symbol', 'sort'),
    ...           ('list',
    ...             ('or',
    ...               ('or',
    ...                 ('symbol', '1'),
    ...                 ('symbol', '2')),
    ...               ('symbol', '3')),
    ...             ('negate',
    ...               ('symbol', 'rev')))),
    ...         ('and',
    ...           ('symbol', '4'),
    ...           ('group',
    ...             ('or',
    ...               ('or',
    ...                 ('symbol', '5'),
    ...                 ('symbol', '6')),
    ...               ('symbol', '7'))))),
    ...       ('symbol', '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')))
    ic3@s|]}t|��VqdS(N(tsimplifyinfixops(RFR6(ttargetnodes(s4/usr/lib/python2.7/dist-packages/mercurial/parser.pys	<genexpr>�si(R#R$RARKtreversed(R&RLtopt
simplifiedR6RGtr((RLs4/usr/lib/python2.7/dist-packages/mercurial/parser.pyRK�s:
%

cC@sFt|j�dkr7td�|jd|jdfS|jdSdS(s;Compose error message from specified ParseError object
    is	at %s: %siN(R-R4R(tinst((s4/usr/lib/python2.7/dist-packages/mercurial/parser.pytparseerrordetail�s"taliascB@seZdZd�ZRS(sParsed result of aliascC@s1||_||_||_||_t|_dS(N(tnameR4RtreplacementtFalsetwarned(RRTR4terrRU((s4/usr/lib/python2.7/dist-packages/mercurial/parser.pyR�s
				(R(R)t__doc__R(((s4/usr/lib/python2.7/dist-packages/mercurial/parser.pyRS�stbasealiasrulescB@s�eZdZdZdZd�Zed��Zed��Z	e
d��Ze
d��Ze
d��Z
e
d��Ze
d	��Ze
d
��Ze
d��Ze
d��Ze
d
��ZRS(swParsing 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 funciton-call styles::

        # decl = defn
        h = heads(default)
        b($1) = ancestors($1) - ancestors(default)
    tsymbolcC@std|j��dS(Ns'%s' is not instantiatable(t	TypeErrorR((tcls((s4/usr/lib/python2.7/dist-packages/mercurial/parser.pyt__new__scC@s
t�dS(s-Parse an alias name, arguments and definitionN(tNotImplementedError(tspec((s4/usr/lib/python2.7/dist-packages/mercurial/parser.pyR	scC@s
t�dS(s9Return (name, args) if tree is a function; otherwise NoneN(R_(R&((s4/usr/lib/python2.7/dist-packages/mercurial/parser.pyt_trygetfuncsc@sjy�j|�}Wn&tjk
r;}|d
t|�fSX|d�jkr�|d}|jd�r|d
td�|fS|d
d
fS�j|�}|rW|\}}|jd�r�|d
td�|fSt	�fd�|D��r|d
td�fSt
|�t
t|��kr3|d
td�fS|g|D]}|d^q=d
fS|d
td	�fS(sA
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: ('symbol', x)
        >>> symlist = lambda *xs: ('list',) + tuple(sym(x) for x in xs)
        >>> func = lambda n, a: ('func', sym(n), a)
        >>> parsemap = {
        ...     'foo': sym('foo'),
        ...     '$foo': sym('$foo'),
        ...     'foo::bar': ('dagrange', sym('foo'), sym('bar')),
        ...     'foo()': func('foo', None),
        ...     '$foo()': func('$foo', None),
        ...     'foo($1, $2)': func('foo', symlist('$1', '$2')),
        ...     'foo(bar_bar, baz.baz)':
        ...         func('foo', symlist('bar_bar', 'baz.baz')),
        ...     'foo(bar($1, $2))':
        ...         func('foo', func('bar', symlist('$1', '$2'))),
        ...     'foo($1, $2, nested($1, $2))':
        ...         func('foo', (symlist('$1', '$2') +
        ...                      (func('nested', symlist('$1', '$2')),))),
        ...     'foo("bar")': func('foo', ('string', 'bar')),
        ...     'foo($1, $2': error.ParseError('unexpected token: end', 10),
        ...     'foo("bar': error.ParseError('unterminated string', 5),
        ...     'foo($1, $2, $1)': func('foo', symlist('$1', '$2', '$1')),
        ... }
        >>> def parse(expr):
        ...     x = parsemap[expr]
        ...     if isinstance(x, Exception):
        ...         raise x
        ...     return x
        >>> def trygetfunc(tree):
        ...     if not tree or tree[0] != 'func' or tree[1][0] != 'symbol':
        ...         return None
        ...     if not tree[2]:
        ...         return tree[1][1], []
        ...     if tree[2][0] == '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('foo')
        ('foo', None, None)
        >>> builddecl('$foo')
        ('$foo', None, "invalid symbol '$foo'")
        >>> builddecl('foo::bar')
        ('foo::bar', None, 'invalid format')
        >>> builddecl('foo()')
        ('foo', [], None)
        >>> builddecl('$foo()')
        ('$foo()', None, "invalid function '$foo'")
        >>> builddecl('foo($1, $2)')
        ('foo', ['$1', '$2'], None)
        >>> builddecl('foo(bar_bar, baz.baz)')
        ('foo', ['bar_bar', 'baz.baz'], None)
        >>> builddecl('foo($1, $2, nested($1, $2))')
        ('foo($1, $2, nested($1, $2))', None, 'invalid argument list')
        >>> builddecl('foo(bar($1, $2))')
        ('foo(bar($1, $2))', None, 'invalid argument list')
        >>> builddecl('foo("bar")')
        ('foo("bar")', None, 'invalid argument list')
        >>> builddecl('foo($1, $2')
        ('foo($1, $2', None, 'at 10: unexpected token: end')
        >>> builddecl('foo("bar')
        ('foo("bar', None, 'at 5: unterminated string')
        >>> builddecl('foo($1, $2, $1)')
        ('foo', None, 'argument names collide with each other')
        iit$sinvalid symbol '%s'sinvalid function '%s'c3@s"|]}|d�jkVqdS(iN(t_symbolnode(RFR(R](s4/usr/lib/python2.7/dist-packages/mercurial/parser.pys	<genexpr>rssinvalid argument lists&argument names collide with each othersinvalid formatN(RRRRRRRct
startswithRRaRR-tset(R]tdeclR&RQRTR*R4R((R]s4/usr/lib/python2.7/dist-packages/mercurial/parser.pyt
_builddecls(M

$c@s�t|t�s|S|d}|�jkrT|ft��fd�|dD��St|�dkslt�|d}|�kr�d}n+|jd�r�tjtd�|��n||fS(s%Mark alias arguments as ``_aliasarg``ic3@s!|]}�j|��VqdS(N(t_relabelargs(RFR6(R4R](s4/usr/lib/python2.7/dist-packages/mercurial/parser.pys	<genexpr>�siit	_aliasargRbsinvalid symbol '%s'(	R#R$RcR-tAssertionErrorRdRRR(R]R&R4RNtsym((R4R]s4/usr/lib/python2.7/dist-packages/mercurial/parser.pyRhzs
(
	cC@s=|j|�}|r$t|�}n	t�}|j||�S(s9Parse 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.

        >>> parsemap = {
        ...     '$1 or foo': ('or', ('symbol', '$1'), ('symbol', 'foo')),
        ...     '$1 or $bar': ('or', ('symbol', '$1'), ('symbol', '$bar')),
        ...     '$10 or baz': ('or', ('symbol', '$10'), ('symbol', 'baz')),
        ...     '"$1" or "foo"': ('or', ('string', '$1'), ('string', 'foo')),
        ... }
        >>> class aliasrules(basealiasrules):
        ...     _parse = staticmethod(parsemap.__getitem__)
        ...     _trygetfunc = staticmethod(lambda x: None)
        >>> builddefn = aliasrules._builddefn
        >>> def pprint(tree):
        ...     print prettyformat(tree, ('_aliasarg', 'string', 'symbol'))
        >>> args = ['$1', '$2', 'foo']
        >>> pprint(builddefn('$1 or foo', args))
        (or
          ('_aliasarg', '$1')
          ('_aliasarg', 'foo'))
        >>> try:
        ...     builddefn('$1 or $bar', args)
        ... except error.ParseError as inst:
        ...     print parseerrordetail(inst)
        invalid symbol '$bar'
        >>> args = ['$1', '$10', 'foo']
        >>> pprint(builddefn('$10 or baz', args))
        (or
          ('_aliasarg', '$10')
          ('symbol', 'baz'))
        >>> pprint(builddefn('"$1" or "foo"', args))
        (or
          ('string', '$1')
          ('string', 'foo'))
        (RReRh(R]tdefnR4R&((s4/usr/lib/python2.7/dist-packages/mercurial/parser.pyt
_builddefn�s
*	c	C@s�d}}|j|�\}}}|r7td�}nGy|j||�}Wn.tjk
r}}t|�}td�}nX|r�|i|jd6|d6|d6}nt||||�S(s>Parse an alias declaration and definition into an alias objects4bad declaration of %(section)s "%(name)s": %(error)ss3bad definition of %(section)s "%(name)s": %(error)stsectionRTRN(	RRgRRmRRRRt_sectionRS(	R]RfRltrepltefmtRTR4RXRQ((s4/usr/lib/python2.7/dist-packages/mercurial/parser.pytbuild�s
%cC@s@i}x3|D]+\}}|j||�}|||j<q
W|S(sTParse a list of alias (name, replacement) pairs into a dict of
        alias objects(RrRT(R]titemstaliasesRfRlta((s4/usr/lib/python2.7/dist-packages/mercurial/parser.pytbuildmap�s
cC@s�t|t�sdS|d|jkra|d}|j|�}|ra|jdkra|dfSn|j|�}|r�|\}}|j|�}|r�|jdk	r�||fSndS(srIf tree looks like an unexpanded alias, return (alias, pattern-args)
        pair. Return None otherwise.
        iiN(R#R$RRctgetR4Ra(R]RtR&RTRuR*R4((s4/usr/lib/python2.7/dist-packages/mercurial/parser.pyt	_getalias�s


c@sRt|t�s|S|ddkr5|d}�|St��fd�|D��S(soReplace _aliasarg instances with the substitution value of the
        same name in args, recursively.
        iRiic3@s!|]}�j|��VqdS(N(t_expandargs(RFR(R4R](s4/usr/lib/python2.7/dist-packages/mercurial/parser.pys	<genexpr>�s(R#R$(R]R&R4Rk((R4R]s4/usr/lib/python2.7/dist-packages/mercurial/parser.pyRy�s
c
@s�t|t�s|S�j�|�}|dkrTt����fd�|D��S|\}}|jr~tj|j��n|�kr�tjtd�i�jd6|j	d6��n�j
|�|j	�kr��j�|j����|j	<n�|j	}�j
�|jdkr%|St|�t|j�krbtjtd�t|���ng|D]}	�j�|	g��^qi}�j|tt|j|���S(Nc3@s'|]}�j�|���VqdS(N(t_expand(RFR(RttcacheR]t	expanding(s4/usr/lib/python2.7/dist-packages/mercurial/parser.pys	<genexpr>�ss5infinite expansion of %(section)s "%(name)s" detectedRnRTsinvalid number of arguments: %d(R#R$RxRRtAbortRRRoRTRARzRUtpopR4R-RytdictR.(
R]RtR&R|R{RPRuRGtresultR((RtR{R]R|s4/usr/lib/python2.7/dist-packages/mercurial/parser.pyRz�s2	!

+cC@s|j||gi�S(sExpand aliases in tree, recursively.

        'aliases' is a dictionary mapping user defined aliases to alias objects.
        (Rz(R]RtR&((s4/usr/lib/python2.7/dist-packages/mercurial/parser.pytexpandsN(R(R)RYRRoRcR^tstaticmethodRRatclassmethodRgRhRmRrRvRxRyRzR�(((s4/usr/lib/python2.7/dist-packages/mercurial/parser.pyRZ�s	g1
N(t
__future__Rti18nRtRtobjectRR7R?RBRJRKRRRSRZ(((s4/usr/lib/python2.7/dist-packages/mercurial/parser.pyt<module>sE	 					M