3
\f[                #   @   s  d Z ddlZddlmZ ddlmZ ddlmZmZm	Z	m
Z
 ddlmZ ddlmZ edZejd	ejZejd
ejZejdZyeddd W n" ek
r   ejdZdZY nBX ddlmZ ejdjejZdZddlZejd= ddlZe`[ejdZej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+ed"Z,ed#Z-ed$Z.ed%Z/ed&Z0ed'Z1ed(Z2ed)Z3ed*Z4ed+Z5ed,Z6ed-Z7ed.Z8ed/Z9ed0Z:ed1Z;ed2Z<ed3Z=ed4Z>ed5Z?ed6Z@ed7ZAed8ZBed9ZCed:ZDed;ZEed<ZFed=ZGed>ZHed?ZIed@ZJedAZKedBZLedCZMedDZNedEZOedFZPedGZQe!e9e%e(e1e0e4e:e,e6e-e7e+e5e'e2e)e*e.e/e"e&e#e3e$e8dHZReSdIdJ e	eRD ZTeUeReUeTkstVdKejdLdMjWdNdO eXeRdPdQ dRD  ZYeZeGeIeHe;eLeMeNgZ[eZe;eOeIeNgZ\dSdT Z]dUdV Z^dWdX Z_dYdZ Z`d[d\ ZaG d]d^ d^ebZcG d_d` d`edZeeG dadb dbebZfeG dcdd ddebZgdedf ZhG dgdh dhebZidS )ia  
    jinja2.lexer
    ~~~~~~~~~~~~

    This module implements a Jinja / Python combination lexer. The
    `Lexer` class provided by this module is used to do some preprocessing
    for Jinja.

    On the one hand it filters out invalid operators like the bitshift
    operators we don't allow in templates. On the other hand it separates
    template code and python code in expressions.

    :copyright: (c) 2017 by the Jinja Team.
    :license: BSD, see LICENSE for more details.
    N)deque)
itemgetter)implements_iteratorintern	iteritems	text_type)TemplateSyntaxError)LRUCache2   z\s+z7('([^'\\]*(?:\\.[^'\\]*)*)'|"([^"\\]*(?:\\.[^"\\]*)*)")z\d+u   fööz	<unknown>evalz[a-zA-Z_][a-zA-Z0-9_]*F)_identifierz[\w{0}]+Tzjinja2._identifierz(?<!\.)\d+\.\d+z(\r\n|\r|\n)addassigncoloncommadivdoteqfloordivgtgteqlbracelbracketlparenltlteqmodmulnepipepowrbracerbracketrparenZ	semicolonsubtilde
whitespacefloatintegernamestringoperatorblock_begin	block_endvariable_beginvariable_end	raw_beginraw_endZcomment_beginZcomment_endcommentlinestatement_beginlinestatement_endZlinecomment_beginZlinecomment_endlinecommentdatainitialeof)+-/z//*%z**~[](){}z==z!=>z>=<z<==.:|,;c             C   s   g | ]\}}||fqS  rM   ).0kvrM   rM   >C:\prj\env\wsgidav_build_3.6\lib\site-packages\jinja2\lexer.py
<listcomp>   s    rR   zoperators droppedz(%s)rJ   c             c   s   | ]}t j|V  qd S )N)reescape)rN   xrM   rM   rQ   	<genexpr>   s    rV   c             C   s
   t |  S )N)len)rU   rM   rM   rQ   <lambda>   s    rX   )keyc             C   sL   | t krt |  S tdtdtdtdtdtdtdtdt	dt
d	td
tdij| | S )Nzbegin of commentzend of commentr2   zbegin of statement blockzend of statement blockzbegin of print statementzend of print statementzbegin of line statementzend of line statementztemplate data / textzend of template)reverse_operatorsTOKEN_COMMENT_BEGINTOKEN_COMMENT_ENDTOKEN_COMMENTTOKEN_LINECOMMENTTOKEN_BLOCK_BEGINTOKEN_BLOCK_ENDTOKEN_VARIABLE_BEGINTOKEN_VARIABLE_ENDTOKEN_LINESTATEMENT_BEGINTOKEN_LINESTATEMENT_END
TOKEN_DATA	TOKEN_EOFget)
token_typerM   rM   rQ   _describe_token_type   s    ri   c             C   s   | j dkr| jS t| j S )z#Returns a description of the token.r)   )typevalueri   )tokenrM   rM   rQ   describe_token   s    
rm   c             C   s2   d| kr&| j dd\}}|dkr*|S n| }t|S )z0Like `describe_token` but for token expressions.rI      r)   )splitri   )exprrj   rk   rM   rM   rQ   describe_token_expr   s    rq   c             C   s   t tj| S )zsCount the number of newline characters in the string.  This is
    useful for extensions that filter a stream.
    )rW   
newline_refindall)rk   rM   rM   rQ   count_newlines   s    rt   c             C   s   t j}t| jd|| jft| jd|| jft| jd|| jfg}| jdk	rp|jt| jdd|| j f | jdk	r|jt| jdd|| j f d	d
 t	|ddD S )zACompiles all the rules from the environment into a list of rules.r2   blockvariableNZlinestatementz	^[ \t\v]*r5   z(?:^|(?<=\S))[^\S\r\n]*c             S   s   g | ]}|d d qS )rn   NrM   )rN   rU   rM   rM   rQ   rR      s    z!compile_rules.<locals>.<listcomp>T)reverse)
rS   rT   rW   comment_start_stringblock_start_stringvariable_start_stringline_statement_prefixappendline_comment_prefixsorted)environmenterulesrM   rM   rQ   compile_rules   s    






r   c               @   s$   e Zd ZdZefddZdd ZdS )FailurezjClass that raises a `TemplateSyntaxError` if called.
    Used by the `Lexer` to specify known errors.
    c             C   s   || _ || _d S )N)messageerror_class)selfr   clsrM   rM   rQ   __init__   s    zFailure.__init__c             C   s   | j | j||d S )N)r   r   )r   linenofilenamerM   rM   rQ   __call__   s    zFailure.__call__N)__name__
__module____qualname____doc__r   r   r   rM   rM   rM   rQ   r      s   r   c               @   sT   e Zd ZdZf Zdd edD \ZZZdd Z	dd Z
d	d
 Zdd Zdd ZdS )TokenzToken class.c             c   s   | ]}t t|V  qd S )N)propertyr   )rN   rU   rM   rM   rQ   rV      s    zToken.<genexpr>   c             C   s   t j| |tt||fS )N)tuple__new__r   str)r   r   rj   rk   rM   rM   rQ   r      s    zToken.__new__c             C   s*   | j tkrt| j  S | j dkr$| jS | j S )Nr)   )rj   rZ   rk   )r   rM   rM   rQ   __str__   s
    


zToken.__str__c             C   s2   | j |krdS d|kr.|jdd| j | jgkS dS )zTest a token against a token expression.  This can either be a
        token type or ``'token_type:token_value'``.  This can only test
        against string values and types.
        TrI   rn   F)rj   ro   rk   )r   rp   rM   rM   rQ   test   s
    
z
Token.testc             G   s    x|D ]}| j |rdS qW dS )z(Test against multiple token expressions.TF)r   )r   iterablerp   rM   rM   rQ   test_any  s    

zToken.test_anyc             C   s   d| j | j| jf S )NzToken(%r, %r, %r))r   rj   rk   )r   rM   rM   rQ   __repr__  s    zToken.__repr__N)r   r   r   r   	__slots__ranger   rj   rk   r   r   r   r   r   rM   rM   rM   rQ   r      s   r   c               @   s(   e Zd ZdZdd Zdd Zdd ZdS )	TokenStreamIteratorz`The iterator for tokenstreams.  Iterate over the stream
    until the eof token is reached.
    c             C   s
   || _ d S )N)stream)r   r   rM   rM   rQ   r     s    zTokenStreamIterator.__init__c             C   s   | S )NrM   )r   rM   rM   rQ   __iter__  s    zTokenStreamIterator.__iter__c             C   s0   | j j}|jtkr"| j j  t t| j  |S )N)r   currentrj   rf   closeStopIterationnext)r   rl   rM   rM   rQ   __next__  s    


zTokenStreamIterator.__next__N)r   r   r   r   r   r   r   rM   rM   rM   rQ   r     s   r   c               @   s~   e Zd ZdZdd Zdd Zdd ZeZedd	 d
dZ	dd Z
dd ZdddZdd Zdd Zdd Zdd Zdd ZdS )TokenStreamzA token stream is an iterable that yields :class:`Token`\s.  The
    parser however does not iterate over it but calls :meth:`next` to go
    one token ahead.  The current active token is stored as :attr:`current`.
    c             C   s>   t || _t | _|| _|| _d| _tdtd| _	t
|  d S )NFrn    )iter_iterr   _pushedr)   r   closedr   TOKEN_INITIALr   r   )r   	generatorr)   r   rM   rM   rQ   r   /  s    
zTokenStream.__init__c             C   s   t | S )N)r   )r   rM   rM   rQ   r   8  s    zTokenStream.__iter__c             C   s   t | jp| jjtk	S )N)boolr   r   rj   rf   )r   rM   rM   rQ   __bool__;  s    zTokenStream.__bool__c             C   s   |  S )NrM   )rU   rM   rM   rQ   rX   ?  s    zTokenStream.<lambda>z Are we at the end of the stream?)docc             C   s   | j j| dS )z Push a token back to the stream.N)r   r|   )r   rl   rM   rM   rQ   pushA  s    zTokenStream.pushc             C   s"   t | }| j}| j| || _|S )zLook at the next token.)r   r   r   )r   Z	old_tokenresultrM   rM   rQ   lookE  s
    
zTokenStream.lookrn   c             C   s   xt |D ]}t|  q
W dS )zGot n tokens ahead.N)r   r   )r   nrU   rM   rM   rQ   skipM  s    zTokenStream.skipc             C   s   | j j|rt| S dS )zqPerform the token test and return the token if it matched.
        Otherwise the return value is `None`.
        N)r   r   r   )r   rp   rM   rM   rQ   next_ifR  s    zTokenStream.next_ifc             C   s   | j |dk	S )z8Like :meth:`next_if` but only returns `True` or `False`.N)r   )r   rp   rM   rM   rQ   skip_ifY  s    zTokenStream.skip_ifc             C   sX   | j }| jr| jj | _ n:| j jtk	rTyt| j| _ W n tk
rR   | j  Y nX |S )z|Go one token ahead and return the old one.

        Use the built-in :func:`next` instead of calling this directly.
        )	r   r   popleftrj   rf   r   r   r   r   )r   rvrM   rM   rQ   r   ]  s    zTokenStream.__next__c             C   s"   t | jjtd| _d| _d| _dS )zClose the stream.r   NT)r   r   r   rf   r   r   )r   rM   rM   rQ   r   l  s    zTokenStream.closec             C   st   | j j|s^t|}| j jtkr:td| | j j| j| jtd|t	| j f | j j| j| jz| j S t
|  X dS )z}Expect a given token type and return it.  This accepts the same
        argument as :meth:`jinja2.lexer.Token.test`.
        z(unexpected end of template, expected %r.zexpected token %r, got %rN)r   r   rq   rj   rf   r   r   r)   r   rm   r   )r   rp   rM   rM   rQ   expectr  s    zTokenStream.expectN)rn   )r   r   r   r   r   r   r   __nonzero__r   eosr   r   r   r   r   r   r   r   rM   rM   rM   rQ   r   (  s   	
r   c             C   sZ   | j | j| j| j| j| j| j| j| j| j	| j
| jf}tj|}|dkrVt| }|t|< |S )z(Return a lexer which is probably cached.N)ry   block_end_stringrz   variable_end_stringrx   comment_end_stringr{   r}   trim_blockslstrip_blocksnewline_sequencekeep_trailing_newline_lexer_cacherg   Lexer)r   rY   lexerrM   rM   rQ   	get_lexer  s"    
r   c               @   s>   e Zd ZdZdd Zdd ZdddZdd	d
ZdddZdS )r   a  Class that implements a lexer for a given environment. Automatically
    created by the environment class, usually you don't have to do that.

    Note that the lexer is not automatically bound to an environment.
    Multiple environments can share the same lexer.
    c                s  dd }t j}ttd fttd fttd ftt	d ft
td fttd fg}t|}|jrTdpVd}i  |jr\|d}|d||j }|j|j}	||	rd||	jd pd7 }|j|j}	||	rd||	jd pd7 }|d||j }
|
j|j}	|	r
d	||	jd pd}d
}d|||j|||jf }d|||j|||jf }| d< | d< nd||j }|j| _|j| _d|ddjd||j|||j||jf g fdd|D   tdfdf|dtd fgt|d||j||j|f ttfdf|dtdfd fgt |d||j||j|f t!dfg| t"|d||j#||j#f t$dfg| t%|d||j|||j||j|f tt&fdf|dtdfd fgt'|d t(dfg| t)|d!t*t+fdfgi| _,d S )"Nc             S   s   t j| t jt jB S )N)rS   compileMS)rU   rM   rM   rQ   rX     s    z Lexer.__init__.<locals>.<lambda>z\n?r   r9   z^%s(.*)z|%srn   z(?!%s)z^[ \t]*z%s%s(?!%s)|%s\+?z%s%s%s|%s\+?ru   r2   z%srootz(.*?)(?:%s)rJ   z4(?P<raw_begin>(?:\s*%s\-|%s)\s*raw\s*(?:\-%s\s*|%s))c                s&   g | ]\}}d || j ||f qS )z(?P<%s_begin>\s*%s\-|%s))rg   )rN   r   r)	prefix_rerM   rQ   rR     s   z"Lexer.__init__.<locals>.<listcomp>z#bygroupz.+z(.*?)((?:\-%s\s*|%s)%s)z#popz(.)zMissing end of comment tagz(?:\-%s\s*|%s)%sz
\-%s\s*|%sz1(.*?)((?:\s*%s\-|%s)\s*endraw\s*(?:\-%s\s*|%s%s))zMissing end of raw directivez	\s*(\n|$)z(.*?)()(?=\n|$))-rS   rT   whitespace_reTOKEN_WHITESPACEfloat_reTOKEN_FLOAT
integer_reTOKEN_INTEGERname_re
TOKEN_NAME	string_reTOKEN_STRINGoperator_reTOKEN_OPERATORr   r   r   ry   matchrx   grouprz   r   r   joinr   re   r[   r   r]   r\   r   r_   r`   ra   r   rb   TOKEN_RAW_BEGINTOKEN_RAW_ENDrc   rd   TOKEN_LINECOMMENT_BEGINr^   TOKEN_LINECOMMENT_ENDr   )r   r   cr   Z	tag_rulesZroot_tag_rulesZblock_suffix_reZno_lstrip_reZ
block_diffmZcomment_diffZno_variable_reZ	lstrip_reZblock_prefix_reZcomment_prefix_rerM   )r   rQ   r     s    	




zLexer.__init__c             C   s   t j| j|S )z@Called for strings and template data to normalize it to unicode.)rr   r$   r   )r   rk   rM   rM   rQ   _normalize_newlines$  s    zLexer._normalize_newlinesNc             C   s&   | j ||||}t| j|||||S )zCCalls tokeniter + tokenize and wraps it in a token stream.
        )	tokeniterr   wrap)r   sourcer)   r   stater   rM   rM   rQ   tokenize(  s    zLexer.tokenizec       	      c   sj  xb|D ]X\}}}|t kr"qn2|dkr2d}n"|dkrBd}n|dkrPqn|dkrd| j|}n|dkrr|}n|d	krt|}tr|j  rtd
|||n|dkry$| j|dd jddjd}W nH tk
r } z*t|j	dd j
 }t||||W Y dd}~X nX n:|dkr.t|}n&|dkrBt|}n|dkrTt| }t|||V  qW dS )zThis is called with the stream as returned by `tokenize` and wraps
        every token in a :class:`Token` and converts the value.
        r3   r,   r4   r-   r0   r1   r6   keywordr)   zInvalid character in identifierr*   rn   asciibackslashreplacezunicode-escaperI   Nr(   r'   r+   )r0   r1   r   )ignored_tokensr   r   check_identisidentifierr   encodedecode	Exceptionro   stripintr'   	operatorsr   )	r   r   r)   r   r   rl   rk   r   msgrM   rM   rQ   r   .  sD    

"




z
Lexer.wrapc             c   sR  t |}|j }| jr>|r>x"dD ]}|j|r |jd P q W dj|}d}d}dg}	|dk	r|dkr|d ksvtd|	j|d  nd}| j|	d!  }
t|}g }xx|
D ]l\}}}|j	||}|dkrq|r|d"krqt
|trxt|D ]\}}|jtkr|||n|dkrpxt|j D ]0\}}|dk	r.|||fV  ||jd7 }P q.W td| n8|j|d }|s|tkr|||fV  ||jd7 } qW n|j }|dkrN|dkr|jd nv|dkr|jd n`|dkr|jd nJ|d#krN|s&td| ||||j }||krNtd||f ||||s^|tkrj|||fV  ||jd7 }|j }|dk	r|dkr|	j  nT|dkrxHt|j D ] \}}|dk	r|	j| P qW td| n
|	j| | j|	d$  }
n||krtd| |}P qW ||kr0dS td|| |f |||qW dS )%zThis method tokenizes the text and returns the tokens in a
        generator.  Use this method if you just want to tokenize a template.
        

r   r   rn   r   Nrv   ru   zinvalid stateZ_beginr/   r-   r4   z#bygroupz?%r wanted to resolve the token dynamically but no group matchedr+   rC   rD   rA   rB   r?   r@   zunexpected '%s'zunexpected '%s', expected '%s'z#popzC%r wanted to resolve the new state dynamically but no group matchedz,%r yielded empty string without stack changezunexpected char %r at %d)r   r   r   )rv   ru   r   )r/   r-   r4   )rD   rB   r@   r   )r   
splitlinesr   endswithr|   r   AssertionErrorr   rW   r   
isinstancer   	enumerate	__class__r   r   	groupdictcountRuntimeErrorr   ignore_if_emptyr   popend)r   r   r)   r   r   linesnewlineposr   stackZstatetokensZsource_lengthZbalancing_stackregextokensZ	new_stater   idxrl   rY   rk   r6   Zexpected_oppos2rM   rM   rQ   r   W  s    























zLexer.tokeniter)NNN)NN)NN)	r   r   r   r   r   r   r   r   r   rM   rM   rM   rQ   r     s    

)r   )jr   rS   collectionsr   r+   r   jinja2._compatr   r   r   r   jinja2.exceptionsr   jinja2.utilsr	   r   r   Ur   r   r   r   SyntaxErrorr   r   jinja2r   formatpatternsysmodulesr   rr   	TOKEN_ADDTOKEN_ASSIGNTOKEN_COLONTOKEN_COMMA	TOKEN_DIV	TOKEN_DOTTOKEN_EQTOKEN_FLOORDIVTOKEN_GT
TOKEN_GTEQTOKEN_LBRACETOKEN_LBRACKETTOKEN_LPARENTOKEN_LT
TOKEN_LTEQ	TOKEN_MOD	TOKEN_MULTOKEN_NE
TOKEN_PIPE	TOKEN_POWTOKEN_RBRACETOKEN_RBRACKETTOKEN_RPARENTOKEN_SEMICOLON	TOKEN_SUBTOKEN_TILDEr   r   r   r   r   r   r_   r`   ra   rb   r   r   r[   r\   r]   rc   rd   r   r   r^   re   r   rf   r   dictrZ   rW   r   r   r~   r   	frozensetr   r  ri   rm   rq   rt   r   objectr   r   r   r   r   r   r   rM   rM   rM   rQ   <module>   s   





+^